写ssm项目的注意点

注意事项：

注意事项：

输出台乱码

a链接以post提交

表单提交前验证

onsubmit 属性在提交表单时触发。

onsubmit 属性只在中使用。

<form action="/demo/demo_form.asp" onsubmit="checkForm()">

姓：<input type="text" name="lname"><br>

名：<input type="text" name="fname"><br>

<input type="submit" value="提交">

<script>

    function checkForm()

    {

    	alert("表单已提交！");

    }

</script>

跳转前确认

在跳转链接前，需要判断该用户是否有权限打开页面，没有权限的弹出一个确认框提示“没有权限”，有权限的则直接跳转页面。

参考资料一：

http://jingyan.baidu.com/article/425e69e6d043bebe15fc16db.html

a标签点击时跳出确认框

方法一：
<a href="http://www.baidu.com" onClick="return confirm('确定删除?');">[删除]</a>
方法二：
<a onclick="confirm(‘确定要跳转吗？')?location.href='www.baidu.com':''" href="javascript:;">百度</a>
参考资料二：

http://blog.csdn.net/wujiangwei567/article/details/40352689

①在html标签中出现提示
<a href="http://www.baidu.com" onclick="if(confirm('确认百度吗？')==false)return false;">百度</a>
②在js函数中调用
function foo(){

if(confirm("确认百度吗？")){

return true;

}

return false;

}
对应的标签改为：
<a href="http://www.baidu.com" onclick="return foo();">百度</a>
注意事项：

以上参考资料总结：

1.跳转的方法：

1>. 把连接放在a元素的href属性中进行页面跳转

2>. 使用location.href进行页面跳转

c:if 判断

字符串与域中的字符串是否相等

1、<c:if test="${student.sex eq '男'}我是空格"></c:if>,注意是${student.sex eq '男'}后面的空格

2、<c:if test="${student.sex eq '男'}"></c:if>

注意不要有多余的空格，判断相等用eq关键字

jsr303验证表单

@PostMapping("/editStudent")

    public String editStudentUI(@Valid @ModelAttribute Student student , BindingResult result, Model model){

        if (!bindResult(result, model)){

            return "error";

        }

        try {

            studentServiceImpl.update(student);

        } catch (Exception e) {

            e.printStackTrace();

        }

        return "redirect:/admin/showStudent";

    }

     public boolean bindResult(BindingResult result, Model model){

        if (result.hasErrors()){

            List<String> errors=new ArrayList<>();

            List<ObjectError> errorList = result.getAllErrors();

            for(ObjectError error : errorList){

                errors.add(error.getDefaultMessage());

            }

            model.addAttribute("error",errors);

            return false;

        } else{

            return true;

        }

    }

package com.system.pojo.base;

import org.hibernate.validator.constraints.NotBlank;

import org.springframework.format.annotation.DateTimeFormat;

import javax.validation.constraints.NotNull;

import java.util.Date;

public class Student {

    private Integer userid;

    @NotBlank(message = "姓名不能为空")

    private String username;

    private String sex;

    private Date birthyear;

    private Date grade;

    private Integer collegeid;

    public Integer getUserid() {

        return userid;

    }

    public void setUserid(Integer userid) {

        this.userid = userid;

    }

    public String getUsername() {

        return username;

    }

    public void setUsername(String username) {

        this.username = username == null ? null : username.trim();

    }

    public String getSex() {

        return sex;

    }

    public void setSex(String sex) {

        this.sex = sex == null ? null : sex.trim();

    }

    public Date getBirthyear() {

        return birthyear;

    }

    public void setBirthyear(Date birthyear) {

        this.birthyear = birthyear;

    }

    public Date getGrade() {

        return grade;

    }

    public void setGrade(Date grade) {

        this.grade = grade;

    }

    public Integer getCollegeid() {

        return collegeid;

    }

    public void setCollegeid(Integer collegeid) {

        this.collegeid = collegeid;

    }

    @Override

    public String toString() {

        return "Student{" +

                "userid=" + userid +

                ", username='" + username + '\'' +

                ", sex='" + sex + '\'' +

                ", birthyear=" + birthyear +

                ", grade=" + grade +

                ", collegeid=" + collegeid +

                '}';

    }

}

Ajax

参数：

url: 请求地址

type: 请求方式 (默认是get请求)

headers:

data: 待发送的参数数据key/value

success:成功之后的回调函数

dataType: 将服务器端返回的数据转成指定类型（"xml","json","text","html","jsonp"...）

$.post

shiro

shiro注解

Shiro的常用注解

@RequiresPermissions ：要求当前Subject在执行被注解的方法时具备一个或多个对应的权限。

@RequiresRoles("xxx") ：要求当前Subject在执行被注解的方法时具备所有的角色，否则将抛出AuthorizationException异常。

@RequiresAuthentication：要求在访问或调用被注解的类/实例/方法时，Subject在当前的session中已经被验证。

jsp中Shiro使用的标签

需要在jsp页面中引入标签

<%@ taglib uri="http://shiro.apache.org/tags" prefix="shiro" %>

标签：

shiro:authenticated 认证且不是记住我

shiro:notAuthenticated 未身份认证，包括记住我自动登录

shiro:guest 用户没有认证在没有RememberMe时

shiro:user 用户认证且在RememberMe时

<shiro:hasAnyRoles name="abc,123" > 在有abc或者123角色时

<shiro:hasRole name="abc"> 拥有角色abc

<shiro:lacksRole name="abc"> 没有角色abc

<shiro:hasPermission name="abc"> 拥有权限资源abc <shiro:lacksPermission name="abc"> 没有abc权限资源

shiro:principal 显示用户身份名称

<shiro:principal property="username"/> 显示用户身份中的属性值

shiro使用

Subject:相当于用户

SecurityManager:相当于DispatcherServlet

Realm:相等于DataSource

导入依赖

<dependency>

            <groupId>org.apache.shiro</groupId>

            <artifactId>shiro-core</artifactId>

            <version>1.2.3</version>

        </dependency>

        <dependency>

            <groupId>org.apache.shiro</groupId>

            <artifactId>shiro-web</artifactId>

            <version>1.2.3</version>

        </dependency>

        <dependency>

            <groupId>org.apache.shiro</groupId>

            <artifactId>shiro-spring</artifactId>

            <version>1.2.3</version>

        </dependency>

....

//– shiro-all-1.3.2.jar

//– log4j-1.2.15.jar

//– slf4j-api-1.6.1.jar

//– slf4j-log4j12-1.6.1.jar

web.xml

<!-- name要和 applicationContext.xml中的对应的bean的id一致 -->

    <!--Shiro拦截器 shiro入口-->

   <filter>

        <filter-name>shiroFilter</filter-name>

        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>

        <init-param>

            <!-- 该值缺省为false,表示生命周期由SpringApplicationContext管理,设置为true则表示由ServletContainer管理 -->

            <param-name>targetFilterLifecycle</param-name>

            <param-value>true</param-value>

        </init-param>

    </filter>

    <filter-mapping>

        <filter-name>shiroFilter</filter-name>

        <url-pattern>/*</url-pattern>

    </filter-mapping>

配置文件

配置自定义的realm类、（或者自动扫描）--》创建realm对象，如：myRealm
配置DefaultWebSecurityManager，需要用到realm对象--》创建DefaultWebSecurityManager，如：securityManager
配置ShiroFilterFactoryBean，需要用到DefaultWebSecurityManager对象---》创建ShiroFilterFactoryBean，如：shiroFilter（与web.xml中过滤器名字配置的一致）

URL 权限采取第一次匹配优先的方式

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:context="http://www.springframework.org/schema/context"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

	http://www.springframework.org/schema/beans/spring-beans.xsd

	http://www.springframework.org/schema/context

	http://www.springframework.org/schema/context/spring-context.xsd

	">

    <!--配置自定义realm类-->

   <!-- <bean id="myRealm" class="com.system.realm.MyRealm">

        <property name="credentialsMatcher">

            <bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">

                <property name="hashAlgorithmName" value="MD5"></property>

                <property name="hashIterations" value="1024"></property>

            </bean>

        </property>

    </bean>-->

    <context:component-scan base-package="com.system.realm" />

    <!--安全管理器-->

    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">

        <property name="realm" ref="myRealm"/>

    </bean>

     <!--与web.xml中过滤器名称一致-->

    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">

        <!-- Shiro的核心安全接口,这个属性是必须的 -->

        <property name="securityManager" ref="securityManager"/>

        <!-- 身份认证失败，则跳转到登录页面的配置 -->

        <!-- 要求登录时的链接(登录页面地址)，非必须的属性，默认会自动寻找Web工程根目录下的"/login.jsp"页面 -->

        <!--<property name="loginUrl" value="/login.jsp"/>

        <property name="successUrl" value="/index.jsp"/>-->

        <!-- 权限认证失败，则跳转到指定页面 -->

        <!--<property name="unauthorizedUrl" value="/login.htmls"/>-->

        <!-- Shiro连接约束配置,即过滤链的定义 -->

        <property name="filterChainDefinitions">

            <value>

                <!--anon 表示匿名访问，不需要认证以及授权-->

                <!--authc表示需要认证 没有进行身份认证是不能进行访问的-->

                <!--当访问login时，不用进行认证-->

                /login = anon

                <!--配置静态资源可以匿名访问-->

                /css/** = anon

                /dist/** = anon

                /js/** = anon

                /fonts/** = anon

                /admin/** = authc,roles[admin]

                /teacher/** = authc,roles[teacher]

                /student/** = authc,roles[student]

                /logout = logout

                <!--只有登陆界面可以匿名访问，其他路径都需要登录认证才能访问，没有登陆访问其他路径回跳转登陆页面-->

                /**=authc

            </value>

        </property>

    </bean>

    <!-- 生命周期 -->

    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />

    <!-- 启用shiro注解 -->

    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor"/>

    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">

        <property name="securityManager" ref="securityManager"/>

    </bean>

</beans>

自定义realm

package com.system.realm;

import com.system.pojo.base.Role;

import com.system.pojo.base.User;

import com.system.service.RoleService;

import com.system.service.UserLoginService;

import org.apache.shiro.authc.*;

import org.apache.shiro.authz.AuthorizationInfo;

import org.apache.shiro.authz.SimpleAuthorizationInfo;

import org.apache.shiro.realm.AuthorizingRealm;

import org.apache.shiro.subject.PrincipalCollection;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import java.util.HashSet;

import java.util.Set;

/**

 * @Description: 自定义的Realm

 * @Date 2020/3/21

 **/

@Component

public class MyRealm extends AuthorizingRealm {

    @Autowired

    private UserLoginService userLoginServiceImpl;

    @Autowired

    private RoleService roleServiceImpl;

    /**

     * @Description: 权限验证,获取身份信息

     * @Param0: principalCollection

     * @Return: org.apache.shiro.authz.AuthorizationInfo

     **/

    @Override

    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {

        //1、获取当前用户名

        String  username = (String) getAvailablePrincipal(principalCollection);

        Role role = null;

        //2、通过当前用户名从数据库中获取用户信息

        try {

            User user = userLoginServiceImpl.findByName(username);

            //3、获取角色信息

            role=roleServiceImpl.findById(user.getRole());

        } catch (Exception e) {

            e.printStackTrace();

        }

        //4、为当前用户设置角色和权限

        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

        //用来存放角色码的集合

        Set<String> r = new HashSet<String>();

        if (role != null) {

            r.add(role.getRolename());

            //5、把用户角色码交给shiro

            info.setRoles(r);

        }

        return info;

    }

    /**

     * @Description: 身份验证,login时调用

     * @Param0: authenticationToken

     * @Return: org.apache.shiro.authc.AuthenticationInfo

     **/

    @Override

    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

        //用户名

        String username = (String) token.getPrincipal();

        //密码

        String password = new String((char[])token.getCredentials());

        //获取用户信息

        User user=null;

        try {

           user = userLoginServiceImpl.findByName(username);

        } catch (Exception e) {

            e.printStackTrace();

        }

        //

        if (user == null) {

            //没有该用户名

            throw new UnknownAccountException();

        } else if (!password.equals(user.getPassword())) {

            //密码错误

            throw new IncorrectCredentialsException();

        }

       /* ByteSource salt = ByteSource.Util.bytes(user.getSalt());//盐值

        SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(user.getName(),

                user.getPassWord(),salt,getName());*/

        SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(username, password, getName());

        return authenticationInfo;

    }

}

controller中身份验证
1. 封装用户名，密码
2. 调用Subject.login方法进行登录，不匹配会出现 AuthenticationException 异常
3. 自定义的realm类，重写doGetAuthenticationInfo() 方法
controller中获取登录信息
1. SecurityUtils.getSubject()获取subject
2. subject.getPrincipal()
controller中获取授权信息
1. subject.hasRole("xxx")，角色码集合中的值
2. 或者subject.isPermitted()

controller代码实例：

@RequestMapping(value = "/login", method = {RequestMethod.POST})

public String login(User user,Model model) throws Exception{

    UsernamePasswordToken token = new UsernamePasswordToken(user.getUsername(),

                                                            user.getPassword());

    //应用代码直接交互的对象是 Subject,Subject 代表了当前“用户”

    Subject subject = SecurityUtils.getSubject();

    subject.login(token);

    //如果获取不到用户名就是登录失败，但登录失败的话，会直接抛出异常

    if (subject.hasRole("admin")) {

        return "redirect:/admin/showStudent";

    } else if (subject.hasRole("teacher")) {

        return "redirect:/teacher/showCourse";

    } else if (subject.hasRole("student")) {

        return "redirect:/student/showCourse";

    }

    return "redirect:/login";

}

 //获取登录者信息

    public User getUserInfo(){

        Subject subject = SecurityUtils.getSubject();

        String username= (String) subject.getPrincipal();

        User user=null;

        try {

            user= userLoginServiceImpl.findByName(username);

        } catch (Exception e) {

            e.printStackTrace();

        }

        return user;

    }

日期转换

在 pojo 类的 日期字段 上，添加注解 @DateTimeFormat(pattern="yyyy/MM/dd") 根据自己情况，写具体的日期格式；

上面的仅仅对一个 po 类有效，如果你有很多 pojo 类，都有日期，则直接写一个日期转换类，然后注册到 springMvc 的配置文件里面，一劳永逸；

转换类如下：

import org.springframework.core.convert.converter.Converter;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

/**

 * 完成日期绑定,全局的 ，替换掉  @DateTimeFormat(pattern = "yyyy/MM/dd")

 */

public class DateConverter implements Converter<String, Date> {

    /**

     * 日期转换类

     */

    private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");

    @Override

    public Date convert(String source) {

        try {

            return simpleDateFormat.parse(source);

        } catch (ParseException e) {

            e.printStackTrace();

        }

//        转换失败，就返回 null  ；

        return null;

    }

}

注册到配置文件中

<!--配置 自定义 参数绑定(日期转换)-->

    <bean class="org.springframework.format.support.FormattingConversionServiceFactoryBean" id="conversionService">

        <!--写上自定义的转换器-->

        <property name="converters">

            <list>

                <!--日期 转换 -->

                <bean class="cn.hyc.utils.DateConverter"/>

            </list>

        </property>

    </bean>

 <!--添加到 MVC 注解里面-->

<mvc:annotation-driven validator="validator" conversion-service="conversionService">

在使用 @Request 进行 JSON 数据参数绑定的时候，对日期，需要另作操作；

否则就会报 400 bad request，请求也不会进后台方法；

在 pojo 类的 日期字段的get方法 上添加 @JsonFormat(pattern="yyyy/MM/dd") ；

json乱码

解决输出JSON乱码的问题

我们发现即使，我们在 web.xml 中配置了解决乱码的拦截器，但是输出JSON 到前台的时候，JSON 中的中文还会乱码；

这与我们配置的过滤器无关了，我猜测是在JSON转换器内部，它默认了ISO-8859编码，导致过滤器在拿到数据的时候，就已经是乱码的数据了。它再使用UTF8编码，最终也还是乱码，除非它能智能的先ISO-8859解码，再UTF8编码。

为了解决这个问题，我们需要在springMvc.xml 中的 MVC 注解标签中配置JSON转换器，制定编码为UTF8；

<mvc:annotation-driven validator="validator" conversion-service="conversionService">

        <mvc:message-converters>

            <!-- 处理请求返回json字符串的中文乱码问题 -->

            <bean class="org.springframework.http.converter.StringHttpMessageConverter">

                <property name="supportedMediaTypes">

                    <list>

                        <value>application/json;charset=UTF-8</value>

                    </list>

                </property>

            </bean>

            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>

        </mvc:message-converters>

    </mvc:annotation-driven>

注意哦，对日期进行绑定的时候，JSON是在 字段 get 方法上添加注解，表单是在 字段 上添加注解！

上面的方法，都是前台传来 JSON ，然后转成对象，指定 JSON 中的日期格式，以便正确的转换日期对象；

如果反过来呢，对象转成JSON，直接转换的话 date 类型，就会被转成 183138913131 这样long 类型的一串数字，我们也可以指定转成 JSON 串中 date 的格式：@JSONField(format = "yyyy-MM-dd")

  /**

     * JSON -> 对象，指定JSON 中日期格式，以便转成对象

     */

    @DateTimeFormat(pattern = "yyyy/MM/dd")

    /**

     * 对象 -》 JSON 指定转换以后的字符串中日期对象的格式

     */

    @JSONField(format = "yyyy-MM-dd")

    private Date newsTime;

重置按钮

需要指定为：reset 。默认submit

路径跳转问题：

controller跳转

redirect:/xxx 跳转到根路径下/**，（如果根路径为/，则跳转之后路径为localhost/xxx

redirect:xxx 跳转到同级路径请求、即：在同一个controller里面跳转（假设：不同的controller类有不同的请求映射注解@RequestMapping("/abc"）....,跳转之后路径localhost/abc/xxx，不能实现controller之间的跳转，因为controller类请求路径（abc）不同

forward：同redirect

页面跳转

先配置视图解析器：
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">

     

     <property name="prefix" value="/WEB-INF/jsp/" />

     <property name="suffix" value=".jsp" />

</bean>
return "(想要跳转jsp路径)xxx"

跳转路径：localhost/xxx

如：return "student/showCourse"; 前面没有斜杠，视图解析器里面已经加了

实际jsp所在 D:\ideaFiles\Examination\src\main\webapp\WEB-INF\jsp\student\showCourse.jsp

PageHelper使用

依赖

 <!-- MyBatis分页插件 -->

 <dependency>

     <groupId>com.github.pagehelper</groupId>

     <artifactId>pagehelper</artifactId>

     <version>5.1.2</version>

 </dependency>

配置（5.x.x版本）

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE configuration

        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

    <plugins>

        <plugin interceptor="com.github.pagehelper.PageInterceptor">

            <!-- config params as the following -->

            <property name="helperDialect" value="mysql"/>

        </plugin>

    </plugins>

</configuration>

实现，sql语句不用更改

public PageInfo<Admin> getPageInfo(String keyword, Integer pageNum, Integer pageSize) {

		// 1.调用PageHelper的静态方法开启分页功能

		// 这里充分体现了PageHelper的“非侵入式”设计：原本要做的查询不必有任何修改

		PageHelper.startPage(pageNum, pageSize);

		// 2.执行查询

		List<Admin> list = adminMapper.selectAdminByKeyword(keyword);

		// 3.封装到PageInfo对象中

		PageInfo<Admin> adminPageInfo = new PageInfo<>(list);

		return adminPageInfo;

}

controller条用service返回pageinfo对象，存储到model中