SSM整合流程

1. 创建工程
2. SSM整合
   • Spring
     • SpringConfig
   • Mybatis
     • MybaitsConfig
     • JdbcConfig
     • jdbc.properties
   • SpringMVC
     • ServletConfig
     • SpringMvcConfig
3. 功能模块
   • 表与实体类
   • dao（接口+自动代理）
   • service（接口+实现类）
     • 业务层接口测试（整合Junit）
   • controller
     • 表现层接口测试（PostMan）

Spring整合Mybatis

• 配置

  • SpringConfig

    @Configuration
    @ComponentScan({"com.xhj.service"})
    @PropertySource("classpath:jdbc.properties")
    @EnableTransactionManagement
    @Import({JdbcConfig.class,MybatisConfig.class})
    public class SpringConfig {
    }
    

  • JDBCConfig、jdbc.properties

    public class JdbcConfig {
        @Value("${jdbc.driver}")
        private String driver;
        @Value("${jdbc.url}")
        private String url;
        @Value("${jdbc.username}")
        private String username;
        @Value("${jdbc.password}")
        private String password;
        @Bean
        public DataSource dataSource(){
            DruidDataSource dataSource = new DruidDataSource();
            dataSource.setDriverClassName(driver);
            dataSource.setUrl(url);
            dataSource.setUsername(username);
            dataSource.setPassword(password);
            return dataSource;
        }
        @Bean
        public DataSourceTransactionManager sourceTransactionManager(DataSource dataSource){
            DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
            dataSourceTransactionManager.setDataSource(dataSource);
            return dataSourceTransactionManager;
        }
    }
    

    jdbc.driver=*****
    jdbc.url=*****
    jdbc.username=*****
    jdbc.password=*****
    

  • MybatisConfig

    public class MybatisConfig {
        @Bean
        public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
            SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
            sessionFactoryBean.setDataSource(dataSource);
            sessionFactoryBean.setTypeAliasesPackage("com.xhj.pojo");
            return sessionFactoryBean;
        }
        @Bean
        public MapperScannerConfigurer mapperScannerConfigurer(){
            MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
            mapperScannerConfigurer.setBasePackage("com.xhj.dao");
            return mapperScannerConfigurer;
        }
    }
    

• 模型

  • Book

• 数据层标准开发

  • BookDao

    public interface BookDao {
        //    @Insert("insert into tbl_book values(null,#{type},#{name},#{description})")
        @Insert("insert into tbl_book (type,name,description) values(#{type},#{name},#{description})")
        public void save(Book book);
    
        @Update("update tbl_book set type = #{type}, name = #{name}, description = #{description} where id = #{id}")
        public void update(Book book);
    
        @Delete("delete from tbl_book where id = #{id}")
        public void delete(Integer id);
    
        @Select("select * from tbl_book where id = #{id}")
        public Book getById(Integer id);
    
        @Select("select * from tbl_book")
        public List<Book> getAll();
    }
    

• 业务层标准开发

  • BookService

    @Transactional
    public interface BookService {
        /**
         * 保存
         * @param book
         * @return
         */
        public boolean save(Book book);
    
        /**
         * 修改
         * @param book
         * @return
         */
        public boolean update(Book book);
    
        /**
         * 按id删除
         * @param id
         * @return
         */
        public boolean delete(Integer id);
    
        /**
         * 按id查询
         * @param id
         * @return
         */
        public Book getById(Integer id);
    
        /**
         * 查询全部
         * @return
         */
        public List<Book> getAll();
    }
    

  • BookServiceImpl

    @Service
    public class BookServiceImpl implements BookService {
        @Autowired
        private BookDao bookDao;
        public boolean save(Book book) {
            bookDao.save(book);
            return true;
        }
    
        public boolean update(Book book) {
            bookDao.update(book);
            return true;
        }
    
        public boolean delete(Integer id) {
            bookDao.delete(id);
            return true;
        }
    
        public Book getById(Integer id) {
            return bookDao.getById(id);
        }
    
        public List<Book> getAll() {
            return bookDao.getAll();
        }
    }
    

• 接口测试

Spring整合SpringMVC

• web配置类

  public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
      @Override
      protected Class<?>[] getRootConfigClasses() {
          return new Class[]{SpringConfig.class};
      }
  
      @Override
      protected Class<?>[] getServletConfigClasses() {
          return new Class[]{SpringMvcConfig.class};
      }
  
      @Override
      protected String[] getServletMappings() {
          return new String[]{"/"};
      }
  
      @Override
      protected Filter[] getServletFilters() {
          CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
          characterEncodingFilter.setEncoding("UTF-8");
          return new Filter[]{characterEncodingFilter};
      }
  }
  

• 基于Restful的Controller开发

  @RestController
  @RequestMapping("/books")
  public class BookController {
  
      @Autowired
      private BookService bookService;
  
      @PostMapping
      public boolean save(@RequestBody Book book) {
          return bookService.save(book);
      }
  
      @PutMapping
      public boolean update(@RequestBody Book book) {
          return bookService.update(book);
      }
  
      @DeleteMapping("/{id}")
      public boolean delete(@PathVariable Integer id) {
          return bookService.delete(id);
      }
  
      @GetMapping("/{id}")
      public Book getById(@PathVariable Integer id) {
          return bookService.getById(id);
      }
  
      @GetMapping
      public List<Book> getAll() {
          return bookService.getAll();
      }
  }
  

异常处理器

• 程序开发过程 中不可避免的会遇到异常现象

  

• 出现异常现象的常见位置与常见诱因如下：

  • 框架内部抛出的异常：因使用不合规导致
  • 数据层抛出的异常：因外部服务器故障导致（例如：服务器访问超时）
  • 业务层抛出的异常：因业务逻辑书写错误导致（例如：遍历业务书写操作，导致索引异常等）
  • 表现层抛出的异常：因数据收集、校验等规则导致（例如：不匹配的数据类型间导致异常）
  • 工具类抛出的异常：因工具类书写不严谨不够健壮导致（例如：必要释放的连接长期未释放等）

异常处理器

• 集中的、统一的处理项目中出现的异常

@RestControllerAdvice
public class ProjectExceptionAdvice {
    @ExceptionHandler(Exception.class)
    public Result deException(Exception e){
        System.out.println("危险危险危险");
        return new Result(000,null,"危险危险危险");
    }
}

项目异常处理方案

• 项目异常分类

  • 业务异常（BusinnessException）
    • 规范的用户行为异常
    • 不规范的用户行为异常
  • 系统异常（SystemException）
    • 项目运行过程中可预计且无法避免的异常
  • 其他异常（Exception）
    • 编程人员未预期到的异常

  

  

项目异常处理方案

• 业务异常（BusinessException）
  • 发送对应消息传递给用户，提醒规范操作
• 系统异常（SystemException）
  • 发送固定消息传递给用户，安抚用户
  • 发送特定消息给运维人员，提醒维护
  • 记录日志
• 其他异常（Exception）
  • 发送固定消息传递给用户，安抚用户
  • 发送特定消息给运维人员，提醒维护（纳入预期范围内）
  • 记录日志

项目异常处理

1. 自定义项目系统级异常

   

2. 自定义项目业务级异常

   

3. 自定义异常编码（持续补充）

   

4. 触发自定义异常

   

5. 拦截并处理异常

   

6. 异常处理器效果对比

   

拦截器

拦截器概念

• 拦截器（Interceptor）是一种动态拦截方法调用的机制，在SpringMVC中动态拦截控制器方法的执行
• 作用：
  • 在指定的方法调用前后执行预先设定的代码
  • 阻止原始方法的执行
• 拦截器与过滤器的区别
  • 归属不同：Filter属于Servlet技术，Interceptor属于SpringMVC技术
  • 拦截内容不同：Filter对所有访问进行增强，Interceptor仅针对SpringMVC的访问进行增强

拦截器入门案例

1. 声明拦截器的bean，并实现HandlerInterceptor接口（注意：扫描加载bean）

   @Component
   public class ProjectInterceptor implements HandlerInterceptor {
       @Override
       public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
           System.out.println("preHandle...");
           return true;
       }
   
       @Override
       public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
           System.out.println("postHandle...");
           HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
       }
   
       @Override
       public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
                                   Exception ex) throws Exception {
           System.out.println("afterCompletion...");
           HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
       }
   }
   

2. 定义配置类，继承WebMvcConfigurationSupport，实现addIntercaptor方法（注意：扫描加载配置）

   @Configuration
   public class SpringMvcSupport extends WebMvcConfigurationSupport {
   
       @Autowired
       private ProjectInterceptor projectInterceptor;
       @Override
       protected void addResourceHandlers(ResourceHandlerRegistry registry) {
           super.addResourceHandlers(registry);
       }
   
       @Override
       protected void addInterceptors(InterceptorRegistry registry) {
           registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");
       }
   }
   

3. 添加拦截器并设定拦截的访问路径，路径可以通过可变参数设置多个

   @Override
   protected void addInterceptors(InterceptorRegistry registry) {
       registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");
   }
   

4. 使用标准接口WebMvcConfigurer简化开发（注意：侵入式较强）

   @Configuration
   @ComponentScan({"com.xhj.controller"})
   @EnableWebMvc
   public class SpringMvcConfig implements WebMvcConfigurer {
       @Autowired
       private ProjectInterceptor projectInterceptor;
       @Override
       public void addInterceptors(InterceptorRegistry registry) {
           registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");
       }
   }
   

执行流程

拦截器参数

• 前置处理

  @Override
  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
      System.out.println("preHandle...");
      return true;
  }
  

• 参数

  • request：请求参数
  • Response：响应参数
  • handler：被调用的处理器对象，本质上是一个方法对象，对反射技术中的Method对象进行了在包装

• 返回值

  • 返回值为false，被拦截的处理器将不执行

---

• 后置处理

  @Override
  public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
      System.out.println("postHandle...");
      HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
  }
  

• 参数

  • modeAndView：如果处理器执行完成具有返回结果，可以读取到对应数据与页面信息，并进行调整

---

• 完成后处理

  @Override
  public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
                              Exception ex) throws Exception {
      System.out.println("afterCompletion...");
      HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
  }
  

• 参数

  • ex：如果处理器执行过程中出现异常对象，可以针对异常情况进行单独处理

多拦截器执行顺序

• 当配置多个拦截器时，形成拦截器链
• 拦截器的运行顺序参照拦截器添加顺序为准
• 当拦截器中出现对原始处理器的拦截，后面的拦截器均终止运行
• 当拦截器运行中断，仅运行配置在前面的拦截器的afterCompletion操作

标签：拦截器,return,Day8,黑马,SSM,public,book,异常,id
来源： https://www.cnblogs.com/ltom/p/16676233.html