SSM_SysManager_Security

public class StringToDate implements Converter<String, Date> {
    @Override
    public Date convert(String string) {
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm");
        Date date = null;
        try {
            date = sdf.parse(string);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

 <!-- 配置类型转换器de固定步骤-->
    <!--   01、 先将写好的转换器类放入IOC容器-->
    <bean id="SToDateConvertor" class="com.SH.Converters.StringToDate"></bean>
    <bean id="DToStringConvertor" class="com.SH.Converters.DateToString"></bean>
    <!--  02、 再将自定义的转换器设置到springMVC中的转换器里 -->
    <!--    <bean id="springConvertors" class="org.springframework.context.support.ConversionServiceFactoryBean">这是转换器的类-->
    <!--    由于数据格式化的类是.format.support.FormattingConversionServiceFactoryBean包括了转换器的类，所以可以用格式化的类同时实现两个功能-->
    <bean id="springConvertors" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <property name="converters" >
            <set>
                <ref bean="SToDateConvertor"/>
                <ref bean="xxx"/>
                ...
            </set>
        </property>
    </bean>
    <!-- 03、 在<mvc:annotation-driven>里的conversion-service注册 02的bean  -->
    <!-- 开启SpringMVC注解支持 -->
    <mvc:annotation-driven  conversion-service="springConvertors"/>

 public String getDepartureTimeStr() {
           if (departureTime!=null){
               String pattern="yyyy-MM-dd HH:mm";
               departureTimeStr = DateAndString.DateToString(departureTime, pattern);
           }
            return departureTimeStr;
    }

public class DateAndString {

    public static String DateToString(Date date,String pattern){
        SimpleDateFormat sdf=new SimpleDateFormat(pattern);
        return sdf.format(date);
    }
}

//查询一个订单的具体信息
@Select("select * from orders where id=#{orderId}")
    @Results({
            @Result(column = "id",property = "id",id = true),
            @Result(column = "orderNum",property = "orderNum"),
            @Result(property = "orderTime",column = "orderTime",javaType = Date.class,jdbcType =JdbcType.TIMESTAMP),
            @Result(property = "orderStatus",column = "orderStatus"),
            @Result(property = "peopleCount",column = "peopleCount"),
            @Result(property = "product",column = "productId",javaType = Product.class,one = @One(select = "com.SH.Dao.IproductDao.selectByid")),
            @Result(property = "travellers",column = "id",javaType = List.class,many = @Many(select = "com.SH.Dao.ItravellerDao.selectByid")),
            @Result(property = "member",column = "memberId",javaType = Member.class,one = @One(select = "com.SH.Dao.ImemberDao.selectById")),
            @Result(property = "payType",column = "payType"),
            @Result(property = "orderDesc",column = "orderDesc")
    })
    Orders selectById(String orderId) throws  Exception;

 @Select("select * from member where id=#{id}")
    Member selectById(String id);

 @Select("select * from traveller where id in(
         select travellerId from order_traveller where orderId=#{orderId}
        )")
    List<Traveller> selectByid(String orderId);

 //查询所有用户
    @Select("select * from users")
    @Results({
            @Result(id = true,property = "id",column = "id"),
            @Result(property = "email",column = "email"),
            @Result(property = "username",column = "username"),
            @Result(property = "password",column = "password"),
            @Result(property = "phoneNum",column = "phoneNum"),
            @Result(property = "status",column = "status"),
            @Result(property = "roles",column = "id",javaType = List.class,many = @Many(select = "com.SH.Dao.IroleDao.selectByUserid"))
    })
    List<UserInfo> selectAllUser() throws Exception;

//根据用户id查询角色集
    @Select("select * from role where id in(select roleId from user_role where userId=#{userid})")
    List<Role> selectByUserid(String userid);

<properties>
  <spring.security.version>5.0.1.RELEASE</spring.security.version>
</properties>
<dependencies>
  <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-web</artifactId>
            <version>${spring.security.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-config</artifactId>
            <version>${spring.security.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-core</artifactId>
            <version>${spring.security.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-taglibs</artifactId>
            <version>${spring.security.version}</version>
        </dependency>
</dependencies>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:security="http://www.springframework.org/schema/security"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/security
    http://www.springframework.org/schema/security/spring-security.xsd">


<!--    不拦截的资源-->
    <security:http pattern="/css/**" security="none"/>
    <security:http pattern="/img/**" security="none"/>
    <security:http pattern="/plugins/**" security="none"/>
    <security:http pattern="/page/login.jsp" security="none"/>
    <security:http pattern="/page/fail.jsp" security="none"/>


    <!--
    	配置具体的规则
    	auto-config="true"	不用自己编写登录的页面，框架提供默认登录页面
    	use-expressions="false"	是否使用SPEL表达式
    -->
    <security:http auto-config="true" use-expressions="false">

       <!--  配置具体的拦截的规则, 限制用户添加页面的访问角色 ，小范围在前，大范围在后     -->
        <security:intercept-url pattern="/page/user-add.jsp" access="ROLE_GM"/>

        <!--  pattern="请求路径的规则" access="访问系统的人，必须有USER或GM的角色，ROLE_ 是框架需要的前缀" -->
        <security:intercept-url pattern="/**" access="ROLE_USER,ROLE_GM"/>

        <!-- 设置跳转的页面       -->
        <security:form-login
                login-page="/page/login.jsp" login-processing-url="/login.action"
                default-target-url="/page/main.jsp"
                authentication-failure-url="/page/fail.jsp" authentication-success-forward-url="/page/main.jsp"
                username-parameter="username" password-parameter="password"
                />

        <!-- 关闭跨域请求，csrf主要是为了防止攻击 -->
        <security:csrf disabled="true"/>

        <!-- 用户注销，退出 -->
        <security:logout invalidate-session="true" logout-url="/logout.action" logout-success-url="/page/login.jsp" />

    </security:http>



    <!-- 切换成数据库中的用户名和密码 -->
    <security:authentication-manager>

        <!--配置userService类，它实现了继承了UserDetailsService的IuserService接口，重写了loadUserByUsername(String username)方法，返回一个UserDetails类对象，使用security提供的User对象封装数据库查询到的userinfo信息 -->
    <security:authentication-provider user-service-ref="userService">

       <!-- 配置加密的方式，引用上面配置的加密类，指定密码被加密的方式，框架才能识别，以便找到合适的密码验证方式，不然会报There is no PasswordEncoder mapped for the id "null", 注意！若在xml中配置了加密类，{id}(密码前加{noop}、{bcrypt}等)将不可用，框架会直接使用指定加密类匹配字符串，不会再判断字符串加密类型    -->
<!--        <security:password-encoder ref="passwordEncoder"/>-->


    </security:authentication-provider>
</security:authentication-manager>

    <!-- 配置加密类，存储密码明文的加盐哈希 hash(m+salt)，不可逆加密，验证时匹配哈希值,注意，此项放在 <security:authentication-manager>前会在密码验证时影响{id}是否使用-->
    <bean id="passwordEncoder" class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder"/>


    <!-- 提供了入门的方式，在内存中存入用户名和密码 -->
<!--    <security:authentication-manager>-->
<!--    	<security:authentication-provider>-->
<!--    		<security:user-service>-->
<!--    			<security:user name="sh" password="{noop}123" authorities="ROLE_USER"/>-->
<!--    		</security:user-service>-->
<!--    	</security:authentication-provider>-->
<!--    </security:authentication-manager>-->



</beans>

<!--监听器 -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

<!--指定spring配置文件与security配置文件的位置 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:ApplicationContext.xml,classpath:spring- Security.xml</param-value>
  </context-param>

<!-- 过滤器,filter-name值必须为springSecurityFilterChain-->
  <filter>
    <filter-name>springSecurityFilterChain</filter-name>
    <filter-class>
        org.springframework.web.filter.DelegatingFilterProxy
    </filter-class>
  </filter>

  <filter-mapping>
    <filter-name>springSecurityFilterChain</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

@Service("userService")
@Transactional
public class userServiceImpl implements IuserService {

    @Autowired
    private IuserDao userDao;
    @Autowired
    private BCryptPasswordEncoder passwordEncoder;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {...}

//添加用户，加密测试
    @Override
    public void addUser(UserInfo userInfo) throws Exception {
        //获取用户密码
        String password=userInfo.getPassword();
        //加密密码
        String encode = passwordEncoder.encode(password);
        //修改用户密码
        userInfo.setPassword(encode);
        //打印，以查看加密结果
        System.out.println(encode);
        //插入数据库
        userDao.insertOne(userInfo);


    }

public class UserInfo {

    private String id;
    private String email;
    private String username;
    private String password;
    private String phoneNum;
    private int status;
    private String statusStr;
    private List<Role> roles;

    ....
    //省略setter、getter、构造器
}

//按照用户名查找单个用户，验证登录
    @Select("select * from users where username=#{username}")
    @Results({
            @Result(id = true,property = "id",column = "id"),
            @Result(property = "email",column = "email"),
            @Result(property = "username",column = "username"),
            @Result(property = "password",column = "password"),
            @Result(property = "phoneNum",column = "phoneNum"),
            @Result(property = "status",column = "status"),
            @Result(property = "roles",column = "id",javaType = List.class,many = @Many(select = "com.SH.Dao.IroleDao.selectByUserid"))
    })
    UserInfo selectUserByName(String username);

public interface IuserService extends UserDetailsService {

}

//放入IOC容器，取名为userService，供xml中配置
@Service("userService")
//事务管理
@Transactional
public class userServiceImpl implements IuserService {

    @Autowired
    private IuserDao userDao;

 //重写loadUserByUsername方法
     @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //查询出对应用户信息
        UserInfo userInfo = userDao.selectUserByName(username);
            //获取用户的角色集合
            List<Role> roles = userInfo.getRoles();
            //遍历权限并放入SimpleGrantedAuthority集合
            SimpleGrantedAuthority authority;
            List<SimpleGrantedAuthority> authorities = new ArrayList<>();
            for (Role role : roles) {
                String roleName = role.getRoleName();
                authority = new SimpleGrantedAuthority("ROLE_" + roleName);
                authorities.add(authority);
            }
            //获取用户密码
            String uPwd = userInfo.getPassword();
            //使用Security提供的User类，至少需要用户名、密码、权限
            User user;
            if (uPwd.length() <= 50) {//判断密码长度，以区分是否是加密的密码，因为加密后的密码比较长
                //此时密码未进行加密，所以要加"{noop}"前缀，让框架识别
                user = new User(userInfo.getUsername(), "{noop}" + uPwd, authorities);
            } else {
                //此时密码已经加密(正常情况下密码用户的密码应该不会大于50吧)，加"{bcrypt}"前缀，因为加密方式为bcrypt，让框架识别
                user = new User(userInfo.getUsername(), "{bcrypt}" + uPwd, authorities);
                 //若在xml中配置了加密方式，{id}就会失效，只使用配置的加密方式匹配密码，加密类的bean也不能靠前
            }
            //直接返回User类对象，因为User类实现了UserDetails
            return user;

    }

//均为字符串
{noop}password//无加密，明文密码，前缀使用{noop}让框架识别，noop是no operate的意思

    //各种加密方式的前缀，和对应的密文样式
{bcrypt}$2a$10$dXJ3SW6G7P50lGmMkkmwe.20cQQubK3.HZWzG3YB1tlRy.fqvM/BG //BCryptPasswordEncoder类加密

{pbkdf2}5d923b44a6d129f3ddf3e3c8d29412723dcbde72445e8ef6bf3b508fbf17fa4ed4d6b99ca763d8dc

{scrypt}$e0801$8bWJaSu2IKSn9Z9kM+TPXfOc/9bdYSrN1oD9qfVThWEwdRTnO7re7Ei+fUZRJ68k9lTyuTeUp4of4g24hHnazw==$OAOec05+bXxvuu/1qZ6NUR+xQYvYv7BeL1QxwRpY5Pc=

{sha256}97cde38028ad898ebc02e690819fa220e88c62e0699403e94fff291cfffaf8410849f27605abcbc0

//Security提供的User类
public class User implements UserDetails, CredentialsContainer {
    private static final long serialVersionUID = 500L;
    private String password;
    private final String username;
    private final Set<GrantedAuthority> authorities;
    private final boolean accountNonExpired;
    private final boolean accountNonLocked;
    private final boolean credentialsNonExpired;
    private final boolean enabled;

    public User(String username, String password, Collection<? extends GrantedAuthority> authorities) {
        this(username, password, true, true, true, true, authorities);
    }

    public User(String username, String password, boolean enabled, boolean accountNonExpired, boolean credentialsNonExpired, boolean accountNonLocked, Collection<? extends GrantedAuthority> authorities) {
        if (username != null && !"".equals(username) && password != null) {
            this.username = username;
            this.password = password;
            this.enabled = enabled;
            this.accountNonExpired = accountNonExpired;
            this.credentialsNonExpired = credentialsNonExpired;
            this.accountNonLocked = accountNonLocked;
            this.authorities = Collections.unmodifiableSet(sortAuthorities(authorities));
        } else {
            throw new IllegalArgumentException("Cannot pass null or empty values to constructor");
        }
    }

user = new User(userInfo.getUsername(), "{bcrypt}" + uPwd, authorities);

User user = new User(userInfo.getUsername(), "{bcrypt}" + userInfo.getPassword(),
userInfo.getStatus() == 0 ? false : true, true, true, true, authoritys);

 <security:authentication-manager>

     <!--配置userService类，它实现了继承了UserDetailsService的IuserService接口，重写了loadUserByUsername(String username)方法，返回一个UserDetails类对象，使用security提供的User对象封装数据库查询到的userinfo信息 -->
    <security:authentication-provider user-service-ref="userService">

    </security:authentication-provider>
</security:authentication-manager>

<!--    启用注解,用于进行权限控制-->
<!--    开启JSR250注解、secured注解,支持spel表达式的注解-->
<security:global-method-security jsr250-annotations="enabled" secured-annotations="enabled" pre-post-annotations="enabled"/>

<dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>jsr250-api</artifactId>
            <version>1.0</version>
</dependency>

@Controller
@RequestMapping(value = "/userController")

//指定类内方法都默认需要GM的身份
@RolesAllowed("GM")
public class userController {

    @Autowired
    private IuserService userService;


    //添加用户
@RequestMapping(value = "/addUser")
    public String addUser(UserInfo userInfo) throws Exception {
        userService.addUser(userInfo);
        return "redirect:/userController/findAll.action";
    }


    //查询所有用户
    @RequestMapping(value = "/findAll")

    //指定此方法GM和USER都可以访问
    @RolesAllowed({"GM","USER"})
    public ModelAndView findAllUser() throws Exception {
        List<UserInfo> users = userService.selectAllUser();
        ModelAndView mv=new ModelAndView();
        mv.addObject("userList",users);
        mv.setViewName("user-list");
        return mv;
    }
}

@Controller
@RequestMapping(value = "/userController")

//指定类内方法都默认需要GM的身份
@Secured("ROLE_GM")
public class userController {

    @Autowired
    private IuserService userService;

    //添加用户
@RequestMapping(value = "/addUser")
    public String addUser(UserInfo userInfo) throws Exception {
        userService.addUser(userInfo);
        return "redirect:/userController/findAll.action";
    }

    //查询所有用户
    @RequestMapping(value = "/findAll")

    //指定此方法GM和USER都可以访问
    @Secured({"ROLE_USER","ROLE_GM"})
    public ModelAndView findAllUser() throws Exception {
        List<UserInfo> users = userService.selectAllUser();
        ModelAndView mv=new ModelAndView();
        mv.addObject("userList",users);
        mv.setViewName("user-list");
        return mv;
    }
}

@Controller
@RequestMapping(value = "/userController")

/*指定类内方法都默认需要GM的身份
* @PreAuthorize("hasRole('ROLE_GM')")
 * 或
 * @PreAuthorize("hasAuthority('ROLE_GM')")
 */
public class userController {


    @Autowired
    private IuserService userService;


    //添加用户
@RequestMapping(value = "/addUser")

    public String addUser(UserInfo userInfo) throws Exception {
        userService.addUser(userInfo);

        return "redirect:/userController/findAll.action";
    }


    //查询所有用户
    @RequestMapping(value = "/findAll")
/*
 * 指定此方法GM和USER都可以访问
* @PreAuthorize("hasAnyRole('ROLE_GM','ROLE_USER')")
* 或
 * @PreAuthorize("hasAnyAuthority('ROLE_GM','ROLE_USER')")
**/
    public ModelAndView findAllUser() throws Exception {
        List<UserInfo> users = userService.selectAllUser();
        ModelAndView mv=new ModelAndView();
        mv.addObject("userList",users);
        mv.setViewName("user-list");
        return mv;
    }

    //修改密码（测试）
    @RequestMapping(value = "/changeP")

    //取方法形参中的username，如果传入参数的值与登录用户的值相同，或者拥有GM权限，便可访问
    @PreAuthorize("#username == authentication.principal.username or hasAuthority('ROLE_GM')")
    public String changeP(@P("username") String username) throws  Exception{
        return "ok";
    }
}

@PostAuthorize
User getUser("returnObject.userId == authentication.principal.userId or
hasPermission(returnObject, 'ADMIN')");

<properties>
  <spring.security.version>5.0.1.RELEASE</spring.security.version>
</properties>

<dependencies>
 <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-taglibs</artifactId>
            <version>${spring.security.version}</version>
 </dependency>
</dependencies>

<%@taglib prefix="security" uri="http://www.springframework.org/security/tags" %>

<security:authentication property="" htmlEscape="" scope="" var=""/>

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>

<%@ taglib prefix="security" uri="http://www.springframework.org/security/tags" %>
<html>
<head>
    <title>用户属性</title>
</head>
<body>
 <%--将用户对象在session中命名为user--%>
<security:authentication property="principal" var="user" scope="session"/>
    <p>${user}</p>
    <p>${user.username}</p>

    <%--或直接输出值--%>
<security:authentication property="principal.username"/>
</body>
</html>

// Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

//User principal = (User)authentication.getPrincipal();
//principal.getUsername();

<security:authorize access="" method="" url="" var=""></security:authorize>

<security:accesscontrollist hasPermission="" domainObject="" var=""></security:accesscontrollist>

@Insert("insert into syslog(id,visitTime,username,ip,url,executionTime,method) values(#{id},#{visitTime},#{username},#{ip},#{url},#{executionTime},#{method})")
    boolean insertOne(SysLog sysLog);

@Select("select * from syslog")
    @Results({

            @Result(id = true,property = "id",column = "id"),
            @Result(property = "visitTime",column = "visitTime",javaType = Date.class,jdbcType = JdbcType.TIMESTAMP),
            @Result(property = "username",column = "username"),
            @Result(property = "ip",column = "ip"),
            @Result(property = "url",column = "url"),
            @Result(property = "executionTime",column = "executionTime",javaType = long.class,jdbcType = JdbcType.INTEGER),
            @Result(property = "method",column = "method")

    })
    List<SysLog> selectAll() throws Exception;

public class SysLog {
private String id;
private Date visitTime;
private String visitTimeStr;
private String username;
private String ip;
private String url;
private Long executionTime;
private String method;

    //setter&getter
｝

<!--
    支持AOP的注解支持，AOP底层使用代理技术
    JDK动态代理，要求必须有接口
    cglib代理，生成子类对象，proxy-target-class="true" 默认使用cglib的方式
-->
<aop:aspectj-autoproxy proxy-target-class="true"/>

package com.SH.AOP;

import ...

@Component
@Aspect
public class sysLogAOP {

    @Autowired
    private HttpServletRequest request;
    @Autowired
    private IsysLogService sysLogService;

    private Class aClass;
    private Method method;
    private Date visitTime;
    private String visitTimeStr="";
    private String ip="";
    private String url="";
    private String username="";


    /*
    * 前置通知
    * 生成访问方法时的时间
    *获取操作者的信息
    *获取ip
    *获取访问方法的类、类名、方法、方法名
    *利用方法、类获取requestMapping的valueof[0]，拼接成url
    * 单个方法作为切入点
    * @Before("execution(public String com.SH.Controller.productController.findAll(java.util.Map<java.lang.String,java.lang.Object>))")
    * */
//    全部类型的 com.SH.Controller包下 全部类的全部方法
  @Before("execution(* com.SH.Controller.*.*(..))")//前置通知
    public void BeforeAd(JoinPoint joinPoint) throws NoSuchMethodException,SecurityException {//异常由Class对象中的getMethod方法产生
      //当前访问时间
      visitTime = new Date();
      //转为年-月-日 时:分:秒字符串
      visitTimeStr = DateAndString.DateToString(visitTime, "yyyy-MM-dd HH:mm:ss");


      //获取操作者信息
      SecurityContext context = SecurityContextHolder.getContext();
      User user = (User) context.getAuthentication().getPrincipal();
      username = user.getUsername();//用户名
      Collection<GrantedAuthority> authorities = user.getAuthorities();//角色

    //获取操作者IP地址
    ip = request.getRemoteAddr();

    //获取访问的类和方法，拼接成url
      //获取切入对象的类
      aClass = joinPoint.getTarget().getClass();



      //★获取方法
      //1. 获取切入对象（方法）的名字
       String  methodName=joinPoint.getSignature().getName();

      //2. 获得方法的参数
      Object[] args = joinPoint.getArgs();


      //3. 判断要获取的方法是否有参数
      if (args==null||args.length==0)//没有参数
      {
          //通过方法名获取方法//无参方法获取
          method = aClass.getMethod(methodName);

      }else {//有参数

          //创建一个argsClass数组
          Class[] argsClass=new Class[args.length];
          //循环，获取args数组里每个参数的类，并且装入argsClass数组
          for (int i=0;i<args.length;i++){

              argsClass[i]= args[i].getClass();
          }
          //通过方法名+参数类型获取方法//有参方法获取
          method= aClass.getMethod(methodName,argsClass);//有的方法，参数是基本数据类型如int，方法内int参数换成Integer包装类
      }

      //拼接url
      String classURL="";//类路径
      String methodURL="";//类后方法路径
//      class和method都拿到后，就可以拿到requestMapping注解里的值
      if (aClass!=null&&method!=null&&aClass!=sysLogAOP.class){//防止空指针，并且class不为自身（？看有人这么写）
//获取类和方法的RequestMapping对象
      RequestMapping classAnnotation =(RequestMapping) aClass.getAnnotation(RequestMapping.class);
      RequestMapping methodAnnotation =(RequestMapping) method.getAnnotation(RequestMapping.class);
     if (classAnnotation!=null){
         classURL=classAnnotation.value()[0];
     }
     if (methodAnnotation!=null){
         methodURL=methodAnnotation.value()[0];
     }
//.value()值为数组
      url=classURL+methodURL;
      }


        //打印输出，方便测试
      System.out.println("访问时间"+ visitTimeStr);
      System.out.println("用户："+username+"；身份："+authorities+"IP地址："+ip);
      System.out.println("访问的类"+aClass+"；方法"+methodName+"\n；URL："+url);
      System.out.println("传递参数值："+ Arrays.toString(args));

  }


  /*
  * 后置通知
  * 生成方法的完成时间
  * 计算耗时
  * 封装日志数据
  * 调用service处理
  * */
  @After("execution(* com.SH.Controller.*.*(..))")
    public void AfterAd() throws Exception{
      //记录方法完成的时间
      Date completeTime=new Date();
      //转换成指定格式字符串
      String completeTimeStr =DateAndString.DateToString(completeTime,"yyyy-MM-dd HH:mm:ss");
      //计算耗时
      Long usedTime=completeTime.getTime()-visitTime.getTime();


      //封装数据
      SysLog sysLog=new SysLog();
      sysLog.setId(completeTimeStr);
      sysLog.setVisitTime(visitTime);
      sysLog.setVisitTimeStr(visitTimeStr);
      sysLog.setUsername(username);
      sysLog.setIp(ip);
      sysLog.setUrl(url);
      sysLog.setExecutionTime(usedTime);
      sysLog.setMethod(method.getName());

        //存入数据库
      boolean flag = sysLogService.insertOne(sysLog);

      //打印输出，方便测试
      System.out.println("完成时间："+completeTimeStr+"；耗时："+usedTime+"毫秒");
      System.out.println("封装日志："+sysLog);
      System.out.println("将日志，存入数据库结果："+flag);
    }
}

<!--  为spring提供 request对象,监听器-->
<listener>
 <listener-class>
     org.springframework.web.context.request.RequestContextListener
 </listener-class>
</listener>

SecurityContext context = SecurityContextHolder.getContext();//获取Security上下文对象
User user = (User) context.getAuthentication().getPrincipal();//获取用户对象

//获取对象的类
aClass = joinPoint.getTarget().getClass();
//或
dClass = joinPoint.getSignature().getDeclaringType();

@CallerSensitive
    public Method getMethod(String name, Class<?>... parameterTypes)
        throws NoSuchMethodException, SecurityException {
        checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
        Method method = getMethod0(name, parameterTypes, true);
        if (method == null) {
            throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
        }
        return method;
    }

RequestMapping classAnnotation =(RequestMapping) aClass.getAnnotation(RequestMapping.class);//类的RequestMapping注解
      RequestMapping methodAnnotation =(RequestMapping) method.getAnnotation(RequestMapping.class);//方法的RequestMapping注解

 if (aClass!=null&&method!=null)

if (classAnnotation!=null){
         classURL=classAnnotation.value()[0];
     }
     if (methodAnnotation!=null){
         methodURL=methodAnnotation.value()[0];
     }

String URL=classURL+methodURL;

//获得方法的参数（一个Object数组）
Object[] args = joinPoint.getArgs();

ParameterNameDiscoverer dpnd = new DefaultParameterNameDiscoverer();
String[] argsNames = dpnd.getParameterNames(method);//method是之间获取方法时，得到的Method对象
System.out.println("参数名："+ Arrays.toString(argsNames));

package com.SH.Service.ServiceImpl;

import ...
@Service("userService")//起个名字，供xml中配置
@Transactional
public class userServiceImpl implements IuserService {

    @Autowired
    private HttpServletRequest request;
 ...

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        ...

            //获取用户ip、登录时间
            String ip = request.getRemoteAddr();
//          Date logintime=new Date();
            String logintime=DateAndString.DateToString(new Date(),"yyyy-MM-dd HH:mm:ss");
         //打印以观察
            System.out.println("用户："+username+"登陆ip"+ip+"；时间："+logintime);
          //将数据插入数据库即可
         ...

    }

    @Override
    public void addUser(UserInfo userInfo) throws Exception {... }

<dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.1.2</version>
</dependency>

@RequestMapping("/selectBypage")
    public ModelAndView selectBypage(@RequestParam(name = "pageNum",required = true,defaultValue = "1") int pageNum,
                                    @RequestParam(name = "pageSize",required = true,defaultValue = "10") int pageSize) throws Exception {

        //分页
        PageHelper.startPage(pageNum,pageSize);
        List<SysLog> sysLogList = sysLogService.selectAll();
        //pageInfo封装
        PageInfo pageInfo=new PageInfo<>(sysLogList);

        ModelAndView mv=new ModelAndView();
        mv.setViewName("syslog-list");
        mv.addObject("pageInfo",pageInfo);

        return mv;
    }

//当前页
private int pageNum;
//每页的数量
private int pageSize;
//当前页的数量
private int size;
//排序
private String orderBy;

//可以在页面中"显示startRow到endRow 共size条数据"
//当前页面第一个元素在数据库中的行号
private int startRow;
//当前页面最后一个元素在数据库中的行号
private int endRow;

//总记录数
private long total;
//总页数
private int pages;
//结果集
private List<T> list;

//第一页
private int firstPage;
//前一页
private int prePage;
//下一页
private int nextPage;
//最后一页
private int lastPage;

//是否为第一页
private boolean isFirstPage = false;
//是否为最后一页
private boolean isLastPage = false;
//是否有前一页
private boolean hasPreviousPage = false;
//是否有下一页
private boolean hasNextPage = false;
//导航页码数
private int navigatePages;
//所有导航页号
private int[] navigatepageNums;

<%@ page language="java" contentType="text/html; charset=UTF-8"
 pageEncoding="UTF-8" isELIgnored="false" %>

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>