Java总结

曾经终败给现在 2024-02-19 17:15 12阅读 0赞

#### 项目总结 ####

*   *  1.在非spring ioc环境中获取容器中的bean
     *  2.前后端分离配置跨域
     *  3.Spring Boot中使用Jpa
     *  4.Spring Boot中使用JPA
     *  5.Spring MVC 全局异常处理（返回指定格式）
     *   *  1.前置知识
         *  2.定义发生异常后的标准返回格式
         *  3.定义异常
         *  4.指定全局异常处理类
         *  5.在Controller中测试
     *  6.Spring Boot Web环境集成Spring Security
     *   *  1.前置知识
         *  2.自定义认证思路
         *  3.代码实现
         *  配置完善
         *   *  配置匿名用户访问无权限资源时的异常
         *  4.配置权限控制
     *  7.使用Aop记录日志
     *   *  a.前置知识-Spring Aop
         *  b.使用aop记录日志

### 1.在非spring ioc环境中获取容器中的bean ###

举个简单的例子，在spring的项目中，比如Service类上会标记@Service注解加载到spring容器中，Controller类上会标记@Controller注解，将该类加载到Spring容器中。两个类都在spring的容器中，那么才可以在一个类中使用@Autowired注解注入另一个类。如果是一个不在Spring容器中的类是不能够通过@Autowired注解去获取容器中的bean的，此时可以通过下面这个方法来实现在一个非ioc容器类中获取ioc容器中的bean的方法：

package com.admintest.utils;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.DisposableBean;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    
    /**
     * ApplicationContextAware：用于获取spring上下文环境，作用：比如有一个bean在Spring容器中，如果想要在非spring容器bean中
     *              使用，此时是不能通过注入的方式来得到这个bean的，但是可以通过这个spring上下文来获取
     *              实现ApplicationContextAware接口，将要实现setApplicationContext方法，一个用于初始化上下
     *  DisposableBean：实现该接口要实现改接口的destroy()方法，改方法会在改类对应的实例销毁时被调用，与之相反的接口是InitializingBean，
     *              实现InitializingBean的类要实现afterPropertiesSet()方法，在类加载后会调用afterPropertiesSet()方法
     * 注意这里的@Slf4j 是lombok插件提供的注解
      */
    @Slf4j
    public class SpringContextUtil implements ApplicationContextAware, DisposableBean {
        
        /**
         * spring上下文
         */
        private static ApplicationContext applicationContext = null;
    
        /**
         * 检查applicationContext是否为null
         */
        private static void assertContextInjected() {
        
            if (applicationContext == null) {
        
                throw new IllegalStateException("applicationContext未注入，请注入后使用...");
            }
        }
    
        /**
         * 清除application，使之为null
         */
        public static void clearContext()  {
        
            log.debug("清楚SpringContextUtil中的applicationContext，值为null");
            applicationContext = null;
        }
    
        /**
         * 销毁上下文环境
         * @throws Exception
         */
        @Override
        public void destroy() throws Exception {
        
            clearContext();
        }
    
        /**
         * 获取spring上下文applicationContext
         * @param applicationContext
         * @throws BeansException
         */
        @Override
        public void setApplicationContext(org.springframework.context.ApplicationContext applicationContext) throws BeansException {
        
            SpringContextUtil.applicationContext = applicationContext;
        }
    
        /**
         * 直接获取上下文
         * @return
         */
        public static ApplicationContext getApplicationContext() {
        
            // 检测application是否已经初始化
            assertContextInjected();
            return applicationContext;
        }
    
        /**
         * 根据bean的名字从spring上下文中获取bean对象
         * @param beanName bean的别名
         * @param <T>
         * @return
         */
        public static <T> T getBean(String beanName) {
        
        	assertContextInjected();
            T bean = (T)applicationContext.getBean(beanName);
            return bean;
        }
    
        /**
         * 根据bean的类型从spring上下文中获取bean对象
         * @param beanType  bean类型
         * @param <T>
         * @return
         */
        public static <T> T getBean(Class<T> beanType) {
        
       		assertContextInjected();
            T bean = applicationContext.getBean(beanType);
            return bean;
        }
    
    }

使用方式：在项目启动时加载改类到spring 容器即可

@SpringBootApplication
    public class App {
        
    
        public static void main(String[] args) {
        
            SpringApplication.run(App.class, args);
        }
    
        @Bean
        public SpringContextUtil springContextUtil() {
        
            return new SpringContextUtil();
        }
    
    }

### 2.前后端分离配置跨域 ###

在resources新建一个mine目录，在mine目录里新建新建index.html文件  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTIyNTE2OTAy_size_16_color_FFFFFF_t_70]  
配置静态资源访问，使访问/my/\*\*的请求都去classpath:/mine/路径下寻找资源：

package com.admintest.config;
    
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.CorsRegistry;
    import org.springframework.web.servlet.config.annotation.EnableWebMvc;
    import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    
    @Configuration
    public class WebConfig implements WebMvcConfigurer {
        
        /**
         * 配置静态资源映射
         * @param registry
         */
        @Override
        public void addResourceHandlers(ResourceHandlerRegistry registry) {
        
            // 设置要处理的请求资源路径
            registry.addResourceHandler("/my/**").
                    // 设置映射路径
                    addResourceLocations("classpath:/mine/")
                    // 设置缓存时间
                    .setCachePeriod(0);
        }
    
    }

以上配置生效，当在浏览器访问http://localhost:8080/my/index.html，就会访问对应的resources/mine下的index.html文件了。

### 3.Spring Boot中使用Jpa ###

*  Jpa中的实体对象  
    使用jpa，一个实体对象就是对应的数据库中的一张表

package com.admintest.system.domain;
    
    import lombok.Data;
    import lombok.Getter;
    import lombok.Setter;
    import org.hibernate.annotations.CreationTimestamp;
    
    import javax.persistence.*;
    import javax.validation.constraints.NotBlank;
    import java.sql.Timestamp;
    import java.util.Set;
    
    /**
     * 菜单表
     *
     * @Entity jpa注解 标注这是一个实体类，对应的是数据库中的一张表
     * @Getter/@Setter  是lombok插件提供的注解，用来生成get/set方法
     * @Table jpa注解 @Table用于指定当前实体对应的表，name属性用于指定表面，不指定则为实体名
     */
    @Entity
    @Getter
    @Setter
    @Table(name = "munu")
    public class Menu {
        
    
        /**
         * 主键ID
         *
         * @Id jpa注解 标识当前标注的属性/字段是数据库表主键
         * @GeneratedValue jpa注解，标注如何生成当前属性值 strategy指定策略为自增主键 GenerationType.IDENTITY
         */
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
    
        /**
         * 菜单名字
         */
        private String name;
    
        /**
         * 排序
         * @Column JPA注解，用于修饰当前属性 unique=true 标识给这个字段加唯一约束
         */
        @Column(unique = true)
        private Long sort;
    
        /**
         * 菜单路径
         * name属性为当前指定在数据库中指定一个名字 否则就是实体属性名作为数据库字段名
         */
        @Column(name = "path")
        private String path;
    
        /**
         * 备注
         */
        private String component;
    
        /**
         * 图标
         */
        private String icon;
    
        /**
         * 上级菜单id
         * nullable 用来指定当前属性是否能为null
         */
        @Column(name = "pid", nullable = false)
        private Long pid;
    
        /**
         * 是否为外链 true/false
         */
        @Column(name = "i_frame")
        private Boolean iFrame;
    
        /**
         * 外键关联
         * @ManyToMany JPA注解，多对多映射 多对多关联要生成中间表
         * @JoinTable 指定要关联的表
         *              name属性就是用来指定中间表的名字
         *              joinColumns指定当前表要关联的属性 JoinColumn指定一个字段 name中间表字段名 referencedColumnName关联表字段名
         *              inverseJoinColumns指定关联表属性 JoinColumn指定一个字段 name中间表字段名 referencedColumnName关联表字段名
         *              比如：中间表有个menu_id是关联的Menu表的id字段 中间表role_id字段关联表role的id字段
         */
        @ManyToMany
        @JoinTable(name = "menus_roles",
                joinColumns = {
        
                    @JoinColumn(name = "menu_id", referencedColumnName = "id")
                },
                inverseJoinColumns = {
        
                    @JoinColumn(name = "role_id", referencedColumnName = "id")
                }
        )
        private Set<Role> roles;
    
        /**
         * 创建时间
         * Timestamp 表示用时间戳存储时间
         */
        @CreationTimestamp
        @Column(name = "create_time")
        private Timestamp createTime;
    
    }

在Menu实体类中关联了Role实体类（两个表关联）  
在Menu中：

class Menu {
        
    	// ....
    	@ManyToMany
        @JoinTable(name = "menus_roles",
                joinColumns = {
        
                    @JoinColumn(name = "menu_id", referencedColumnName = "id")
                },
                inverseJoinColumns = {
        
                    @JoinColumn(name = "role_id", referencedColumnName = "id")
                }
        )
        private Set<Role> roles;
        // ....
    }

在Role中：

class Role {
        
    	@JsonIgnore
        @ManyToMany(mappedBy = "roles")
        private Set<Menu> menus;
    }

`@JsonIgnore`注解的作用是在序列化成json的时候忽略这个字段，如果不忽略的话虚拟化menu的时候，menu里面有role，role里面又有menu，这样就会出现死循环（最终导致栈溢出）  
`@ManyToMany(mappedBy = “roles”)`其中的mappedBy属性，标识关联关系由谁来维护，roles是menu中的属性，标识是有menu方来维护关联关系的，在role中添加menu是不能构建关联关系的。

### 4.Spring Boot中使用JPA ###

*  使用JPA，在配置文件中配置 application.yml

*  配置数据源（以Druid为例），在引入Druid依赖后，会添加spring.druid属性来配置：

spring:
      #配置 Jpa
      jpa:
        properties:
          hibernate:
            # 配置数据库方言
            dialect: org.hibernate.dialect.MySQL5InnoDBDialect
        # 配置open-in-view  见https://blog.csdn.net/johnf_nash/article/details/80658626
        open-in-view: true
        hibernate:
          # 配置启动项目时根据实体更新数据库表字段
          ddl-auto: update
    
      # 配置数据源
      datasource:
        druid:
          # 配置实用的数据库驱动
          driver-class-name: com.mysql.cj.jdbc.Driver
          url: jdbc:mysql://localhost:3306/admintest?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false
          username: root
          password: 123456

要注意一点的是，引入jpa后，会自动扫描标记了@Entity注解的实体。也可以配置扫描路径以及repository路径：

@EnableJpaRepositories("com.jxs.dao")
    @EntityScan("com.jxs.pojo")

*  配置Repository接口  
    一般来说，数据库实体->DAO->Service->Controller，要操作数据库就要通过DAO，在Spring Data JPA中，创建DAO的方式很简单，只需要继承指定的接口就可以了。

/**
     * Menu 实体对应的数据dao
     * JpaRepository<Menu, Long> 第一个是对应要操作的实体对象 第二个是该实体对象的主键类型
     */
    public interface MenuRepository extends JpaRepository<Menu, Long>, JpaSpecificationExecutor<Menu> {
        
    }

比如通过继承JpaRepository就可以做一些基本的增删改查操作了，继承JpaSpecificationExecutor可以做一些高级查询。而且也能通过@Autowire注入其它类中使用。

### 5.Spring MVC 全局异常处理（返回指定格式） ###

#### 1.前置知识 ####

首先了解下`@ControllerAdvice`注解，也叫控制器增强，同时还提供了`@InitBinder`，`@ModelAttribute`，`@ExceptionHandler`三个注解，起作用分别是：

@InitBinder：这个标记的方法在在请求入参时执行
    @ModelAttribute：这个标记的方法在执行请求方法之前执行
    @ExceptionHandler：这个标记的方法会在请求方法抛出致辞那个异常时执行

@ControllerAdvice
    public class GloableHandler {
        
        /**
         * @ExceptionHandler 标记方法上，如果出现异常会执行这个方法
         * @InitBinder 执行初始化
         * @ModelAttribute 在controller所有方法执行前执行
         */
    
        @InitBinder
        public void init(WebDataBinder binder) {
        
            System.out.println("initBinder...执行");
            binder.registerCustomEditor(Date.class,
                    new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"),
                            // 是否允许为空
                            false));
            System.out.println("initBinder...执行结束");
        }
    
        @ModelAttribute
        public void modelAttribute(Model model) {
        
            System.out.println("model attribute执行");
            model.addAttribute("auth", "tom");
            System.out.println(model);
            System.out.println("model attribute执行结束");
        }
    
        @ExceptionHandler(value = UserNotExistException.class)
        public ResponseEntity handlerUserNotExistException(UserNotExistException e) {
        
            System.out.println("有异常时执行");
            ApiError apiError = new ApiError(e.status, e.getMessage());
            System.out.println("有异常时执行结束");
            return new ResponseEntity(apiError, HttpStatus.valueOf(apiError.getStatus()));
        }
    
    }

`@InitBinder`，这个注解标记的方法会在处理请求，绑定请求参数时执行，如果没有请求参数绑定，那么这个方法也不会执行。通常会在这个方法中传入一个**WebDataBinder**，这个类可以用来定义处理参数的方式，如下所示，定义了一个处理前端请求的方式，当前端传入 yyyy-MM-dd 格式的时间时会绑定到date类型的参数中。

@InitBinder
    public void init(WebDataBinder binder) {
        
        System.out.println("initBinder...执行");
        binder.registerCustomEditor(Date.class,
                new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"),
                        // 是否允许为空
                        false));
        System.out.println("initBinder...执行结束");
    }

`@ModelAttribute`，这个注解标注的方法会在每个处理请求的方法之前执行，通常用法是在这个注解标注的方法注入一个Model参数，这个Model参数可以用来传递数据，在请求方法的参数中同样注入Model可以获取到数据。

@ModelAttribute
    public void modelAttribute(Model model) {
        
        System.out.println("model attribute执行");
        model.addAttribute("auth", "tom");
        System.out.println(model);
        System.out.println("model attribute执行结束");
    }

`ExceptionHandler`：这个注解标注的方法在请求方法抛出对应异常时执行，比如请求方法抛出UserNotExistException这个异常，那么对应的这个注解标记的方法就会执行，返回也相当于是请求的返回。通常用来做异常处理。

@ExceptionHandler(value = UserNotExistException.class)
    public ResponseEntity handlerUserNotExistException(UserNotExistException e) {
        
        System.out.println("有异常时执行");
        ApiError apiError = new ApiError(e.status, e.getMessage());
        System.out.println("有异常时执行结束");
        return new ResponseEntity(apiError, HttpStatus.valueOf(apiError.getStatus()));
    }

#### 2.定义发生异常后的标准返回格式 ####

示例：

{
        
        "status": 400,
        "timestamp": "2019-02-19 23:10:24",
        "message": "用户不存在"
    }

其中**status**表示状态码，**timestamp**表示错误时间，**message**表示错误提示，也可以定制其他类型比如请求路径path等等。  
对应的Java类`ApiError.java`：

/**
     * 前端接口返回标准形式
     */
    @Data
    public class ApiError {
        
        private Integer status;
        // json序列化 格式 yyyy-MM-dd HH:mm:ss
        @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
        private LocalDateTime timestamp;
        private String message;
        public ApiError() {
        
            this.timestamp = LocalDateTime.now();
        }
        public ApiError (Integer status, String msg) {
        
            this.status = status;
            this.message = msg;
            this.timestamp = LocalDateTime.now();
        }
    }

`@JsonFormat`：在服务器向前端传输json数据时，时通过把java对象json序列化后在传输的，@JsonFormat注解指定如何序列化，上面例子表示把时间按指定格式序列化。

#### 3.定义异常 ####

在接口中抛出异常，异常类必须继承**RuntimeException**，因为RutimeException才不用显示处理，否则每个接口上都要把异常抛出去。  
下面是系统定义的其中一个异常，`UserNotExistException.java`：

public class UserNotExistException extends RuntimeException {
        
    	// 这里只是给了一个默认的状态码，从HttpStatus中规定的状态码获取的
        public int status = HttpStatus.BAD_REQUEST.value();
        public UserNotExistException(String msg) {
        
            super(msg);
        }
        // 也可以自己指定状态码
        public UserNotExistException(String msg, int status) {
        
            super(msg);
            this.status = status;
        }
    }

#### 4.指定全局异常处理类 ####

全局异常处理类需要用到注解`@ControllerAdvice`和`@ExceptionHandler`:

@ControllerAdvice
    public class GloableHandler {
        
      
      	// 指定要处理的是哪个异常
        @ExceptionHandler(value = UserNotExistException.class)
        public ResponseEntity handlerUserNotExistException(UserNotExistException e) {
        
        	// 获取异常中的信息，包装成ApiError类返回
            ApiError apiError = new ApiError(e.status, e.getMessage());
            
            // 返回异常信息HttpStatus.valueOf()这个方法接收一个状态码
            return new ResponseEntity(apiError, HttpStatus.valueOf(apiError.getStatus()));
        }
    
    }

#### 5.在Controller中测试 ####

@RestController
    @RequestMapping("/user")
    public class UserController {
        
        @GetMapping
        public ResponseEntity getAllUser() {
        
            if (true) {
        
            	// 用来模拟抛出一个异常
                throw new UserNotExistException("用户不存在");
            }
            return ResponseEntity.ok("hello World");
        }
    }

发送请求`/user`，可以看到异常已被定制处理：

{
        
        "status": 400,
        "timestamp": "2019-02-19 23:10:24",
        "message": "用户不存在"
    }

### 6.Spring Boot Web环境集成Spring Security ###

在Spring Boot中导入Spring Security starter就已经自动配置了Spring Security了。这里主要是做前后端分离环境token验证的配置。

#### 1.前置知识 ####

当配置好Spring Security后，启动项目访问接口，就会要求登录。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTIyNTE2OTAy_size_16_color_FFFFFF_t_70 1]  
输入密码后进入UsernamePasswordAuthenticationFilter.java进行认证，把认证好的数据放SecurityContextHolder中保存。

#### 2.自定义认证思路 ####

自己提供登录接口，改接口不需要认证可以直接调用，改接口返回一个用户token，token需呀在请求其他认证接口时携带，自定义filter在UsernamePasswordAuthenticationFilter.java之前执行，校验token。校验token分为两种情况，如果SecurityContextHolder中保存了用户就放行，如果token过期了就不放行。

*  自定义filter，在UsernamePasswordAuthenticationFilter.java之前执行
 *  放行登录接口，登录接口返回token
 *  自定义filter中校验token
 *  自定义filter中判断是否登陆，没登陆就登录，登录了就放行

#### 3.代码实现 ####

*  a.新建User.java  
    用来接收用户的登录参数

@Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class User {
        
        private String username;
        private String password;
    }

*  b.新建LoginController.java  
    用于处理登录请求

@Service
    public class UseTokenDetailsService implements UserDetailsService {
        
        private static User localUser;
    
        static {
        
            localUser = new User("admin", "12345");
        }
    
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        
            if (username.equals(localUser.getUsername())) {
        
                // 构建UserDetails对象，模拟用户权限
                Set<GrantedAuthority> authorities = new HashSet<>();
                authorities.add(new SimpleGrantedAuthority("USER_ADD"));
                return new TokenUser(localUser.getUsername(), localUser.getPassword(), authorities);
            }
            throw new UsernameNotFoundException(username + "用户不存在");
        }
    }

*  c.新建SecurityConfig.java  
    用于配置登录请求允许访问

@Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
        /**
         * 配置所有请求都需要认证
         * @param http
         * @throws Exception
         */
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.csrf().disable()
                    .authorizeRequests()
                    // 下面注释的方式也能放行登录请求
                    //.antMatchers("/auth/login").permitAll()
                    .anyRequest().authenticated();
        }
    
        @Override
        public void configure(WebSecurity web) throws Exception {
        
            web.ignoring()
                    .antMatchers(HttpMethod.POST, "/auth/login");
        }
    
    }

*  d.新建TokenUser.java  
    UserDetailsSerivce返回一个UserDetails对象，这个TokenUser就是UserDetails的实现类：

@AllArgsConstructor
    public class TokenUser implements UserDetails {
        
    
        private final String password;
        private final String username;
    
        @Override
        public Collection<? extends GrantedAuthority> getAuthorities() {
        
            return null;
        }
    
        @Override
        public String getPassword() {
        
            return this.password;
        }
    
        @Override
        public String getUsername() {
        
            return this.username;
        }
    
        @Override
        public boolean isAccountNonExpired() {
        
            return false;
        }
    
        @Override
        public boolean isAccountNonLocked() {
        
            return false;
        }
    
        @Override
        public boolean isCredentialsNonExpired() {
        
            return false;
        }
    
        @Override
        public boolean isEnabled() {
        
            return false;
        }
    }

*  e.新建UseTokenDetailsService.java  
    用于查找用户构建UserDetail

@Service
    public class UseTokenDetailsService implements UserDetailsService {
        
        private static User localUser;
    
        static {
        
            localUser = new User("admin", "12345");
        }
    
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        
            if (username.equals(localUser.getUsername())) {
        
                // 构建UserDetails对象
                return new TokenUser(localUser.getUsername(), localUser.getPassword());
            }
            throw new UsernameNotFoundException(username + "用户不存在");
        }
    }

*  f.新建AuthenticationTokenFilter.java  
    用于验证token

@Configuration
    public class AuthenticationTokenFilter extends OncePerRequestFilter {
        
    
        private UserDetailsService userDetailsService;
        public AuthenticationTokenFilter(@Qualifier("useTokenDetailsService")UserDetailsService userDetailsService) {
        
            this.userDetailsService = userDetailsService;
        }
    
        @Override
        protected void doFilterInternal(HttpServletRequest request,
                                        HttpServletResponse response,
                                        FilterChain filterChain) throws ServletException, IOException {
        
            String username = null;
            // 从请求中获取token
            String token = request.getHeader("Authorization");
            // 请求头中的token形式 Authorization: Bearer <token>，单独获取token
            if (token != null && token.contains("Bearer ")) {
        
                token = token.substring(7);
                // 根据token获取用户信息，假设获取到的用户名就是'admin'
                username = "admin";
    
            }
    
            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
        
                TokenUser userDetails = (TokenUser) userDetailsService.loadUserByUsername(username);
                // 设置登录用户
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails.getUsername(), null, userDetails.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
            filterChain.doFilter(request, response);
        }
    }

*  g.配置AuthenticationTokenFilter.java  
    配置AuthenticationTokenFilter在UsernamePasswordAuthenticationFilter.java之前执行：

@Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Autowired
        private AuthenticationTokenFilter authenticationTokenFilter;
    
        /**
         * 配置所有请求都需要认证
         * @param http
         * @throws Exception
         */
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.csrf().disable()
                    .authorizeRequests()
                    //.antMatchers("/auth/login").permitAll()
                    .anyRequest().authenticated();
            // 配置authenticationTokenFilter在UsernamePasswordAuthenticationFilter之前执行
            http.addFilterBefore(authenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
        }
    
        @Override
        public void configure(WebSecurity web) throws Exception {
        
            web.ignoring()
                    .antMatchers(HttpMethod.POST, "/auth/login");
        }
    
    }

这样一个Spring Security的token验证程序就完成了！

#### 配置完善 ####

##### 配置匿名用户访问无权限资源时的异常 #####

继承此类**AuthenticationEntryPoint.java**  
新建TokenAuthenticationEntryPoint.java

@Component
    public class TokenAuthenticationEntryPoint implements AuthenticationEntryPoint {
        
        @Override
        public void commence(HttpServletRequest request,
                             HttpServletResponse response,
                             AuthenticationException authException) throws IOException, ServletException {
        
            response.sendError(HttpStatus.UNAUTHORIZED.value(), "未登录或登录过期");
    
        }
    }

配置使用此类 ：

@Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Autowired
        private AuthenticationTokenFilter authenticationTokenFilter;
        @Autowired
        private TokenAuthenticationEntryPoint authenticationEntryPoint;
    
        /**
         * 配置所有请求都需要认证
         * @param http
         * @throws Exception
         */
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.csrf().disable()
                    .exceptionHandling().authenticationEntryPoint(authenticationEntryPoint)
                    .and()
                    .authorizeRequests()
                    //.antMatchers("/auth/login").permitAll()
                    .anyRequest().authenticated();
            // 配置authenticationTokenFilter在UsernamePasswordAuthenticationFilter之前执行
            http.addFilterBefore(authenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
        }
    
        @Override
        public void configure(WebSecurity web) throws Exception {
        
            web.ignoring()
                    .antMatchers(HttpMethod.POST, "/auth/login");
        }
    
    }

#### 4.配置权限控制 ####

*  1.开启权限注解功能  
    要开启Spring的权限控制，需要`@EnableGlobalMethodSecurity(prePostEnabled = true)`，这个注解支持。

@Configuration
    @EnableWebSecurity
    @EnableGlobalMethodSecurity(prePostEnabled = true)
    public class SpringSecurity extends WebSecurityConfigurerAdapter {
        
    	// ....
        @Autowired
        private TokenAuthenticationFilter tokenAuthenticationFilter;
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.csrf().disable()
                    .addFilterBefore(tokenAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
        }
    
        @Override
        public void configure(WebSecurity web) throws Exception {
        
            web.ignoring().mvcMatchers(HttpMethod.POST, "/user/login");
        }
    }

*  2.确保用户有权限  
    `SimpleGrantedAuthority auth = new SimpleGrantedAuthority(“ROLE_ADMIN”);`，为用户授权，`ROLE_`前缀，可以可以通过hasRole控制，比如上面这个可以通过`@PreAuthorize(“hasRole(‘ADMIN’)”)`，同时也能通过`@PreAuthorize(“hasAuthority(‘ROLE_ADMIN’)”)`控制。

public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        
            User user = new User(1L,"zhangsan", "123456");
            Set<GrantedAuthority> authorities = new HashSet<>();
            SimpleGrantedAuthority auth = new SimpleGrantedAuthority("ROLE_ADMIN");
            authorities.add(auth);
            return new TokenUser(user.getUsername(), user.getPassword(), authorities);
        }

*  3.控制权限

@GetMapping
        @PreAuthorize("hasAuthority('ROLE_ADMIN')")
        public String getUser() {
        
            return "Success";
        }

配置完善：  
在没有权限访问时，配置自定义处理，实现AccessDeniedHandler.java接口  
TokenAccessDeineHandler.java

@Component
    public class TokenAccessDeineHandler implements AccessDeniedHandler {
        
        @Override
        public void handle(HttpServletRequest request,
                           HttpServletResponse response,
                           AccessDeniedException accessDeniedException) throws IOException, ServletException {
        
            response.sendError(HttpStatus.FORBIDDEN.value(), "没有权限访问");
        }
    }

在配置文件中配置：  
`http.exceptionHandling().accessDeniedHandler(tokenAccessDeineHandler);`

@EnableGlobalMethodSecurity(prePostEnabled = true)
    public class SpringSecurity extends WebSecurityConfigurerAdapter {
        
    
        @Autowired
        private TokenAuthenticationFilter tokenAuthenticationFilter;
        @Autowired
        private TokenAccessDeineHandler tokenAccessDeineHandler;
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.csrf().disable()
                    .addFilterBefore(tokenAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
             
            http.exceptionHandling().accessDeniedHandler(tokenAccessDeineHandler);
        }
    
        @Override
        public void configure(WebSecurity web) throws Exception {
        
            web.ignoring().mvcMatchers(HttpMethod.POST, "/user/login");
        }
    }

### 7.使用Aop记录日志 ###

系统的运行需要记录操作日志，方便查看系统运行状况。如果在需要记录日志的每个方法中都去编写记录日志的操作的话，这样会增加大量工作，为了简便操作，需要通过Aop（切面）来记录日志。

#### a.前置知识-Spring Aop ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTIyNTE2OTAy_size_16_color_FFFFFF_t_70 2]  
在Spring Boot中，整合Aop只需要导入**spring-boot-starter-aop**。

*  1.HelloController.java  
    HelloController.java类，作为测试类，testHello方法作为要切入的方法（切入点）

@RestController
    public class HelloController {
        
    
        @GetMapping("/hello")
        public String testHello(String username) {
        
            return "Hello " + username;
        }
    
    }

*  2.定义切面类

@Aspect // 开启Aop功能
    @Component // 一定要加入Spring 容器
    public class AopDemo {
        
    
        // ProceedingJoinPoint is only supported for around advice
        // 前置通知，设置切入点
        @Before("execution(* com.webloggin.weblogdemo.controller.HelloController.testHello(..))")
        public void doBefor(JoinPoint joinPoint) {
        
            //JoinPoint 指向切入点，可以获取切入点的信息，比如参数、注解、返回值类型等等...
           MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
            GetMapping annotation = methodSignature.getMethod().getAnnotation(GetMapping.class);
            String[] value = annotation.value();
            for (String s : value) {
        
                System.out.println(s);
            }
        }
    
        /**
         * 自定义一个切入点
         */
        @Pointcut("execution(* com.webloggin.weblogdemo.controller.HelloController.testHello(..))")
        public void pointCut() {
        
    
        }
    
        /**
         * 自定义切入点
         */
        @Pointcut("@annotation(org.springframework.web.bind.annotation.PostMapping)")
        public void pointCut2() {
        
    
        }
    
        /**
         * 后置通知，目标方法执行之后执行
         * @param joinPoint
         */
        @After("pointCut()")
        public void doAfter(JoinPoint joinPoint) {
        
            System.out.println("目标方法之后");
        }
    
        /**
         * 返回通知 returning = "result"指定方法返回值保存在哪个参数中
         * @param joinPoint
         * @param result
         */
        @AfterReturning(pointcut = "pointCut2()", returning = "result")
        public void doReturning(JoinPoint joinPoint, Object result) {
        
            System.out.println(result);
        }
    
        /**
         * 异常通知 目标方法执行 异常后执行 throwing = "error" 指定抛出的异常保存在哪个参数中
         * @param joinPoint
         * @param error
         */
        @AfterThrowing(pointcut = "pointCut()", throwing = "error")
        public void doException(JoinPoint joinPoint, Throwable error) {
        
            System.out.println("抛出异常.." + error.getMessage());
        }
    
        @Around("pointCut()")
        public Object doAround(ProceedingJoinPoint joinPoint) {
        
            // 模拟前置通知...
            Object result = null;
            try {
        
                // 让目标方法执行
                result = joinPoint.proceed();
                // 模拟后置通知
            } catch (Throwable throwable) {
        
                throwable.printStackTrace();
                // 模拟异常通知
            }
            return result;
        }
    
    
    }

#### b.使用aop记录日志 ####

*  Log.java  
    这是一个注解，这个注解用来指定切入点表达式的，也可以带一些日志记录用到的参数。

/**
     * 自定义一个注解，用于标记哪些方法需要做日志记录
     */
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Log {
        
        String value() default "";
        // 可以定义一些其它参数，用作日志记录
    }

*  LogAspect.java  
    用于作日志记录

@Component
    @Aspect
    @Log4j2
    public class LogAspect {
        
    
        /**
         * 配置一个切入点
         * @annotation(com.webloggin.weblogdemo.log.Log)
         * 表示切入注解@Log标注的地方
         */
        @Pointcut("@annotation(com.webloggin.weblogdemo.log.Log)")
        public void logPointCut() {
        
    
        }
    
        /**
         * 记录方法执行日志
         * @param joinPoint
         * @return
         */
        @Around("logPointCut()") // 使用上面的切入点
        public Object logAround(ProceedingJoinPoint joinPoint) {
        
    
            Object result = null;
    
            try {
        
                joinPoint.proceed();
            } catch (Throwable t) {
        
                // 报错了
                log.error("出错了");
                throw new RuntimeException(t.getMessage());
            }
            // 入库...
            log.info("没有异常...");
            return  result;
        }
    
        /**
         * 异常通知，记录异常后的日志
         * @param joinPoint
         * @param e
         */
        @AfterThrowing(pointcut = "logPointCut()", throwing = "e")
        public void logAfterThrowable(JoinPoint joinPoint, Throwable e) {
        
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            com.webloggin.weblogdemo.log.Log logAnnotation = method.getAnnotation(com.webloggin.weblogdemo.log.Log.class);
            String value = logAnnotation.value();
    
            String name = signature.getName();
            log.error(name + "->出异常了->" + e.getMessage() + "，注解信息：" + value);
        }
    
    
    }

这样一个使用aop记录日志的功能就完成了。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTIyNTE2OTAy_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/0460d0370fcb42e89028bddd0c2af594.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTIyNTE2OTAy_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/040bb127725d4017a53284824b47cf48.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTIyNTE2OTAy_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/1e895fd3f7734df593637d52e939fc32.png