SSM+Maven高级+MybatisPlus万字笔记

SSM框架学习 一：Spring Framework系统框架

二：Spring核心概念 1.IoC、Bean、DI 1.1：IoC&Bean

• IoC(Inversion of Control)控制反转
  • 使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权转移到外部，此思想称为控制反转。
  • Spring提供了一个容器，称为IoC容器，用来充当IoC思想中的"外部"
  • IoC容器负责对象的创建、初始化等一系列工作，被创建的对象在IoC容器中被称为Bean。

1.2：DI

• DI(Dependency Injection)依赖注入
  • 在容器中建立Bean与Bean之间的依赖关系的整个过程，称为依赖注入。

1.3：最终效果

• 充分解耦
• 使用IoC容器管理Bean
• 在IoC容器内将有依赖关系的Bean进行关系绑定(ID)
• 使用对象时不仅可以直接从IoC容器中获取，并且获取到的Bean已经绑定了所有的依赖关系。

2.快速入门 2.1：导入相关坐标

    org.springframework
    spring-context
    5.2.21.RELEASE

2.2：定义Spring管理的类(接口)

public interface BookDao {
    public void save();
}

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}

public interface BookService {
    public void save();
}

public class BookServiceImpl implements BookService {
    //5.删除业务层中使用new的方式创建的dao对象
    private BookDao bookDao;

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    //6.提供对应的set方法(容器在执行)
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

2.3：创建Spring配置文件，配置对应类作为Spring管理的Bean

applicationContext.xml

2.4：初始化IoC容器(Spring核心容器/Spring容器)，通过容器获取Bean

public static void main(String[] args) {
    //3.加载配置文件得到上下文对象，也就是容器对象
    ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

    //4.获取资源
    // BookDao bookDao = (BookDao) ctx.getBean("bookDao");
    // bookDao.save();
    
    BookService bookService = (BookService) ctx.getBean("bookService");
    bookService.save();
}

3：bean的作用范围

• scope属性用于改变bean的作用范围，默认情况下scope属性为singleton，此时为单例模式，即创建出来的bean都是同一个，当scope属性为prototype时候，即为非单例模式。

• 为什么bean默认情况下为单例模式？可以用一个bean完成多个功能，提高复用性。

• 适合交给容器进行管理的bean：

  • 表现层对象(servlet)
  • 业务层对象(service)
  • 数据层对象(Dao)
  • 工具类对象

• 不适合交给容器进行管理的bean

  • 封装实体的域对象

4：实例化bean的四种方式 4.1：构造方法(常用)

• 需要提供默认构造方法(无参构造方法)
• 如果无参构造方法不存在，将抛出异常BeanCreationException

4.2:静态工厂(了解)

• 静态工厂

  public class OrderDaoFactory{
      public static OrderDao getOrderDao(){
          return new OrderDaoImpl();
      }
  }
  

• 配置

4.3:实例工厂(了解)

4.4：FactoryBean(实用)

• BookDaoFactoryBean.java

public class BookDaoFactoryBean implements FactoryBean {
    @Override
    public BookDao getObject() throws Exception {
        return new BookDaoImpl();
    }

    @Override
    public Class getObjectType() {
        return BookDao.class;
    }
}

• 配置信息

4.5：Bean生命周期

• 初始化容器

  1. 创建对象(内存分配)
  2. 执行构造方法
  3. 执行属性注入(set操作)
  4. 执行bean初始化方法

• 使用Bean

  1. 执行业务操作

• 关闭/销毁容器

  1. 执行bean销毁方法

• bean生命周期控制

  • 配置
    • init-method
    • destroy-method
  • 接口(了解)
    • InitializingBean
    • DisposableBean

• 关闭容器

  • ConfigurableApplicationContext

    • 手工关闭容器

      ConfigurableApplicationContext接口close()操作

    • 注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机

      ConfigurableApplicationContext接口registerShutdownHook()操作

5：向类传递数据 5.1：依赖注入方式

1. setter注入
   • 简单类型
   • 引用类型
2. 构造器注入
   • 简单类型
   • 引用类型

5.2：setter注入

1. 引用类型

   • 在bean中定义引用数据类型属性并提供可访问的set方法

     private UserDao userDao;
     
     public void setUserDao(UserDao userDao) {
         this.userDao = userDao;
     }
     

   • 配置中使用property标签ref属性注入引用类型对象

2. 简单类型

   • 在bean中定义引用类型属性并提供可访问的set方法

     BookDaoImpl

     public class BookDaoImpl implements BookDao {
         private int conNum;
         private String dbName;
     
         public void setConNum(int conNum) {
             this.conNum = conNum;
         }
     
         public void setDbName(String dbName) {
             this.dbName = dbName;
         }
     
         public void save() {
             System.out.println("book dao save ..."+conNum+" "+dbName);
         }
     }
     

   • 配置中使用property标签value属性注入简单类型数据

5.3：构造器注入

1. 引用类型

   • 在bean中定义引用数据类型属性并提供可访问的构造方法

     private BookDao bookDao;
     private UserDao userDao;
     
     public BookServiceImpl(BookDao bookDao, UserDao userDao) {
         this.bookDao = bookDao;
         this.userDao = userDao;
     }
     

   • 配置中使用constructor-arg标签ref属性注入引用类型对象

2. 简单类型

   • 在bean中定义简单数据类型属性并提供可访问的构造方法

     private int conNum;
     private String dbName;
     
     public BookDaoImpl(int conNum, String dbName) {
         this.conNum = conNum;
         this.dbName = dbName;
     }
     

   • 配置中使用constructor-arg标签value属性注入简单类型对象

   • 配置中使用constructor-arg标签type属性设置按照形参类型注入

   • 配置中使用constructor-arg标签index属性设置按照形参位置注入

5.4：依赖注入方式选择

5.5：自动类型的装配

1. 使用bean标签autowire属性设置自动装配的类型(byType、byName(耦合度高，不推荐))

2. 依赖自动装配特征

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y8PTeIUR-1653122017072)(SSM笔记.assets/image-20220515195109170.png)]

5.6：注入集合

public class BookDaoImpl implements BookDao {
    private int[] array;
    private List list;
    private Set set;
    private Map map;
    private Properties properties;

    public void setArray(int[] array) {
        this.array = array;
    }

    public void setList(List list) {
        this.list = list;
    }

    public void setSet(Set set) {
        this.set = set;
    }

    public void setMap(Map map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void save() {
        System.out.println(Arrays.toString(array));
        System.out.println(list);
        System.out.println(set);
        System.out.println(map);
        System.out.println(properties);
    }
}

``

    
        
            100
            200
            300
        
    

    
        
            country
            aaa
            bbb
        
    

    
        
            100
            aaa
            
            aaa
            bbb
        
    

    
        
    

    
        
            china
            guangdong
            guangzhou
        
    

6：数据源对象管理 6.1：基本配置

6.1.1导入Druid坐标

    com.alibaba
    druid
    1.1.16

6.1.2配置数据源对象作为spring管理的bean

6.2：加载properties文件

6.2.1.开启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"> 

6.2.2.使用context命名空间，加载指定properties文件

6.2.3.使用${}读取加载的属性值

6.2.4.其他设置

6.2.5.加载配置文件

6.2.6.容器相关

6.2.7获取bean

6.3：注解开发bean

6.3.1使用@Componet定义bean

@Component("bookDao")
public class BookDaoImpl implements BookDao {
}

@Component
public class BookServiceImpl implements BookService {
}

6.3.2核心配置文件中通过组件扫描加载bean

6.3.3 Spring提供@Component注解的三个衍生注解(与Component功能一样)

@Controller  //用于表现层bean定义
@Service  //用于业务层定义bean
@Repository  //用于数据层bean定义

7：纯注解开发: 7.1：基本配置

7.1.1：Spring3.0开启了纯注解开发模式，使用Java类替代配置文件，开启了Spring快速开发赛道

7.1.2：Java类代替Spring核心配置文件

com.my.config.SpringConfig.java

@Configuration   //用于设定当前类为配置类
// @ComponentScan("com.my")  
@ComponentScan({"com.my.service","com.my.dao"})  //用于设定扫描路径，只能添加一次，多个数据用数组格式
public class SpringConfig {
}

7.1.3：读取Spring核心配置文件初始化容器对象切换为读取Java配置类初始化容器对象

public static void main(String[] args) {
    ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
    //获取资源 按bean名称获取
    BookDao bookDao = (BookDao) ctx.getBean("bookDao");
    System.out.println(bookDao);

    // 按bean类型获取
    BookService bookService = ctx.getBean(BookService.class);
    System.out.println(bookService);
}

7.1.4：小结

7.2：作用范围及生命周期

7.3：依赖注入

7.3.1：注入引用类型

7.3.2：简单数据类型

@Value("${}")
private String name;

7.3.3：小结

7.4：第三方Bean的注入

7.5：XML配置VS注解配置

8：Spring整合Mybatis 8.1：jdbcConfig

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 ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
    }

8.2：mybatisConfig

public class mybatisConfig {
    //替换xml基本配置信息
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setTypeAliasesPackage("com.my.pojo");
        sqlSessionFactoryBean.setDataSource(dataSource);
        return sqlSessionFactoryBean;
    }

    //替换
    
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.my.dao");
        return msc;
    }
}

8.3：SpringConfig

@Configuration
@ComponentScan("com.my")
@PropertySource("classpath:jdbc.properties")
@Import({jdbcConfig.class,mybatisConfig.class})
public class SpringConfig {
}

9：Spring整合Junit 9.1：导入坐标

    junit
    junit
    4.13
    test



    org.springframework
    spring-test
    5.2.20.RELEASE

9.2：创建junit测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testFindById(){
        Account ac = accountService.findById(1);
        System.out.println(ac);
    }

    @Test
    public void testFindAll(){
        for (Account account : accountService.findAll()) {
            System.out.println(account);
        }

    }
}

10：AOP(面向切面编程) 10.1：基本概念

• AOP(Aspect Oriented Programming)面向切面编程，一种编程规范，指导开发者如何组织程序结构

  • OOP：面向对象编程

• 作用：在不惊动原始设计的基础上为其进行功能增强

• Spring概念：无侵入式/无入侵式

• 连接点(JoinPoint)：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等

  • 在SpringAOP中，理解为方法的执行

• 切入点(Pointcut)：匹配连接点的式子

  • 在SpringAOP中，一个切入点可以描述一个具体方法，也可以匹配多个方法
    • 一个具体方法：com.my.dao包下的BookDao接口中的无形参无返回值的save()方法
    • 匹配多个方法：所有的save方法，所有以get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法。

• 通知(Advice)：在切入点处执行的操作，也就是共性功能

  • 在SpringAOP中，功能最终以方法的形式呈现

• 通知类：定义通知的类

• 切面(Aspect)：描述通知与切入点的对应关系

10.2：入门案例

10.2.1：导入aop相关坐标

    org.aspectj
    aspectjweaver
    1.9.4

10.2.2：实现dao接口与实现类

@Repository
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save ...");
    }

    @Override
    public void update() {
        System.out.println("book dao update...");
    }
}

10.2.3：定义通知类，制作通知

10.2.4：定义切入点

10.2.5：绑定切入点与通知关系，并指定通知添加到原始连接点的具体执行位置

10.2.6：定义通知类受Spring容器管理，并定义当前类为切面类

@Component   //6.1 定义通知类受Spring容器管理
@Aspect  //6.2 定义当前类为切面类
public class MyAdvice {
    //4.定义切入点
    @Pointcut("execution(void com.my.dao.BookDao.update())")
    public void pt(){}

    //3.定义通知类
    @Before("pt()")  //5.绑定切入点与通知关系，并指定通知添加到原始连接点的具体执行位置
    public void before(){
        System.out.println(System.currentTimeMillis());
    }
}

10.2.7：开启Spring对Aop注解驱动支持

@Configuration
@ComponentScan("com.my")
@EnableAspectJAutoProxy  //7.开启Spring对Aop注解驱动支持
public class SpringConfig {
}

10.2.8：其他代码

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.update();
    }
}

10.3：AOP执行流程

10.4：AOP切入点表达式

10.5：AOP通知

10.5.1：前置通知 @Before

10.5.2：后置通知 @After

10.5.3：环绕通知(重点)

●参数ProceedingJoinPoint参数必须放在第一位。

10.5.4：返回后通知(了解) @AfterReturning 原始切入点方法正常执行完毕后运行

10.5.5：抛出异常通知(了解) @AfterThrowing 抛出异常后执行，不抛异常不执行

10.6：执行效率案例

@Component
@Aspect
public class ProjectAdvice {
    @Pointcut("execution(* com.my.service.*Service.*(..))")
    private void servicePt(){}

    @Around("ProjectAdvice.servicePt()")
    public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
        //获取执行签名信息
        Signature signature = pjp.getSignature();
        //通过签名获取执行类型(接口名)
        String className = signature.getDeclaringTypeName();
        //通过签名获取执行操作名称(方法名)
        String methodName = signature.getName();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            Object ret = pjp.proceed();
        }
        long end = System.currentTimeMillis();
        System.out.println("执行"+className+"."+methodName+"万次耗时"+(end-start)+"ms");
    }
}

10.7：AOP通知获取数据

10.7.1：获取参数

10.7.2：获取返回值

11：Spring事务 11.1：开启事务步骤

11.2：事务角色

11.3：事务配置&传播行为

11.3.1：事务配置

11.3.2：事务传播

11.3.3：案例

1. 在jdbcConfig中添加事务管理器

//设置事务管理器
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource){
    DataSourceTransactionManager ptm = new DataSourceTransactionManager();
    ptm.setDataSource(dataSource);
    return ptm;
}

2. 在SpringConfig中开启事务支持

@Configuration
@ComponentScan("com.my")
@PropertySource("classpath:jdbc.properties")
@Import({jdbcConfig.class,mybatisConfig.class})
@EnableAspectJAutoProxy   //开启Spring对Aop注解驱动的支持
@EnableTransactionManagement //开启事务支持
public class SpringConfig {
}

3. Dao层操作

//数据层操作
public interface AccountDao {
    @Update("update tbl_account set money = money + #{money} where name = #{name}")
    void inMoney(@Param("name")String name,@Param("money")Double money);

    @Update("update tbl_account set money = money - #{money} where name = #{name}")
    void outMoney(@Param("name") String name,@Param("money") Double money);
}

public interface LogDao {
    @Insert("insert into tbl_log(info,createDate) values(#{info},now())")
    void log(String info);
}

4. Service层

public interface AccountService {
    @Transactional
    public void transfer(String out,String in,Double money);
}

public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void log(String out,String in,Double money);

}

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    @Autowired
    private LogService logService;

    @Override
    public void transfer(String out, String in, Double money) {
        try{
            accountDao.outMoney(out,money);
            int a = 1/0;
            accountDao.inMoney(in,money);
        }finally {
            logService.log(out,in,money);
        }
    }
}

@Service
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    @Override
    public void log(String out, String in, Double money) {
        logDao.log(out+"向"+in+"转账"+money+"钱");
    }
}

5. Test

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    @Autowired
    AccountService accountService;

    @Test
    public void transferTest(){
        accountService.transfer("Tom","Jerry",100D);
    }
}

三：SpringMVC 1：概述

• SpringMVC是一种基于Java实现MVC模型的轻量级Web框架
• 优点
  • 使用简单，开发便捷(相比于Servlet)
  • 灵活性强

2：快速入门

2.1：导入坐标

    
        javax.servlet
        javax.servlet-api
        3.1.0
        provided
    

    
        org.springframework
        spring-webmvc
        5.2.10.RELEASE
    

2.2：初始化SpringMVC环境

@Configuration
@ComponentScan("com.my")   //设定SpringMVC加载对应bean
public class SpringMVCConfig {
}

2.3：创建SpringMVC控制器类(等同于Servlet功能)

@Controller
public class UserController {
    @RequestMapping("/save")  //设置当前控制器方法请求访问路径
    @ResponseBody   //设置当前控制器方法响应内容为当前返回值，无需解析
    public String save(){
        System.out.println("user save...");
        return "{'info':'springmvc'}";
    }
}

2.4：初始化Servlet容器，加载SpringMVC环境，并设置SpringMVC请求拦截的路径

//AbstractDispatcherServletInitializer类是SpringMVC提供的快速初始化Web3.0容器的抽象类
public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    //初始化容器并注册返回容器到Tomcat中，以便可以访问bean
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringMVCConfig.class);
        return ctx;
    }

    //设定SpringMVC对应的请求映射路径，设置为/表示拦截所有请求，任意请求都将转入到SpringMVC进行处理
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    //如果创建Servlet容器时需要加载非SpringMVC对应的bean，使用当前方法进行，使用方式同createServletApplicationContext()
    @Override
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }
}

3:Controller加载控制与业务Bean加载控制

4：URL传递参数

• 正常情况下名称对名称

  • 普通参数 save(String name,int age)

  • 封装对象 save(User user)

  • 数组 save(String[] array)

    参数设置 array 10、array 20…

• 名称对不上用@RequestParam

  • 集合 save(@RequestParam List list)

    参数设置 list 10、list 20…

5：JSON数据传递参数

5.1：添加JSON数据转换坐标

    com.fasterxml.jackson.core
    jackson-databind
    2.12.6.1

5.2：在body中设置JSON数据并发送

5.3：开启自动转换JSON数据的支持

@Configuration
@ComponentScan("com.my")
@EnableWebMvc    //开启自动转换JSON数据的支持，开启SpringMVC多项辅助功能
public class SpringMVCConfig {
}

5.4：设置接收JSON数据

@Controller
public class UserController {
    @ResponseBody  //将请求中请求体所包含的数据传递给请求参数，此注解一个方法只能使用一次
    @RequestMapping("/listParamForJson")
    public String listParamForJson(@RequestBody List likes){
        System.out.println("list common(json)参数传递==>" + likes);
        return "{'info':'springmvc'}";
    }

6：日期类型参数传递

• dataParam(Date date, //2020/2/12

  @DateTimeFormat(pattern=“yyyy-MM-dd”) Date date1, //2020-5-17

  @DateTimeFormat(pattern=“yyyy/MM/dd HH:mm:ss”) Date date2 //2020/02/20 20:20:20

  )

7：响应

//响应页面/跳转页面
@RequestMapping("/toJumpPage")
public String toJumpPage(){
    System.out.println("跳转页面");
    return "page.jsp";
}

//响应纯文本数据
@RequestMapping("/toText")
@ResponseBody
public String toText(){
    System.out.println("返回纯文本数据");
    return "response text";
}

//响应POJO对象
@RequestMapping("/toJsonPOJO")
@ResponseBody
public User toJsonPOJO(){
    System.out.println("返回json对象数据");
    User user = new User();
    user.setName("Tom");
    user.setAge(20);
    return user;
}

//响应POJO集合对象
@RequestMapping("/toJsonList")
@ResponseBody
public List toJsonList(){
    System.out.println("返回JSON集合数据");
    User user1 = new User();
    user1.setName("Tom");
    user1.setAge(15);

    User user2 = new User();
    user2.setName("Jerry");
    user2.setAge(18);

    User user3 = new User();
    user3.setName("Jack");
    user3.setAge(20);

    List users = new ArrayList<>();
    users.add(user1);
    users.add(user2);
    users.add(user3);
    return users;
}

8：REST

8.1：概述

8.2：REST风格案例

// REST/POST
@RequestMapping(value = "/users", method = RequestMethod.POST)
@ResponseBody
public String save() {
    System.out.println("user save...");
    return "{'module':'user save'}";
}

@RequestMapping(value = "/users/{id}",method = RequestMethod.DELETE)
@ResponseBody
public String delete(@PathVariable Integer id) {
    System.out.println("user delete..."+id);
    return "{'module':'user delete'}";
}

@RequestMapping(value = "/users",method = RequestMethod.PUT)
@ResponseBody
public String update(@RequestBody User user){
    System.out.println("user update..."+user);
    return "{'module':'user update'}";
}

//查询
@RequestMapping(value = "/users/{id}",method = RequestMethod.GET)
@ResponseBody
public String getById(@PathVariable Integer id){
    System.out.println("user getById..."+id);
    return "{'module':'user getById'}";
}

8.3：简化

@RestController("/book")
public class BookController {
    // REST/POST
    @PostMapping
    public String save() {
        System.out.println("book save...");
        return "{'module':'book save'}";
    }

    @DeleteMapping("/{id}")
    public String delete(@PathVariable Integer id) {
        System.out.println("book delete..."+id);
        return "{'module':'book delete'}";
    }
    
    @PutMapping
    public String update(@RequestBody Book book){
        System.out.println("book update..."+book);
        return "{'module':'book update'}";
    }

    //查询
    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("book getById..."+id);
        return "{'module':'book getById'}";
    }
    
    @GetMapping
    public String getAll(){
        System.out.println("book getAll...");
        return "{'module':'book getAll'}";
    }
}

8.4：设置对静态资源的放行

public class SpringMvcSupport extends WebMvcConfigurationSupport {
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        //当访问/pages/???时候，走pages目录下的内容，防止被SpringMVC拦截
        registry.addResourceHandler("/pages
@RestControllerAdvice   //将类声明为异常处理类
public class ProjectExceptionAdvice {
    @ExceptionHandler(SystemException.class)  //定义处理哪一种异常
    public Result doSystemException(SystemException ex){
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员，ex对象发送给开发人员
        return new Result(ex.getCode(),null,ex.getMessage());
    }

    @ExceptionHandler(BusinessException.class)  //定义处理哪一种异常
    public Result doBusinessException(BusinessException ex){
        return new Result(ex.getCode(),null,ex.getMessage());
    }

    @ExceptionHandler(Exception.class)  //定义处理哪一种异常
    public Result doException(Exception ex){
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员，ex对象发送给开发人员
        return new Result(Code.SYSTEM_UNKNOWN_ERR,null,"系统繁忙，请稍后再试!");
    }
}

10.3.5：捕捉异常

com.my.controller.BookController.java

@GetMapping(value = ("/getById"))
public Result getById(@RequestParam("id") Integer id) {
    if(id == 0){
        throw new BusinessException(Code.BUSINESS_ERR,"请规范您的操作!");
    }
    //将可能出现的异常进行包装，转换成自定义异常
    try{
        int i = 1/0;
    }catch (Exception e){
        throw new SystemException(Code.SYSTEM_TIMEOUT_ERR,"服务器访问超时，请稍后再试!",e);
    }
    Book book = bookService.getById(id);
    Integer code = (book == null? Code.GET_ERR:Code.GET_OK);
    String msg = (book == null? "数据查询失败！":"");
    return new Result(code,book,msg);
}

11：拦截器

11.1：声明拦截器的bean，并实现HandlerInterceptor接口(注意：扫描加载bean)

package com.my.controller.interceptor;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@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...");
    }

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

11.2：定义配置类，继承WebMvcConfigurationSupport，实现addInterceptor方法(注意：扫描加载配置)

package com.my.config;

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    //设置过滤静态访问资源
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/pages
    LambdaQueryWrapper lqw = new LambdaQueryWrapper();
    BookQuery bookQuery = new BookQuery();
    bookQuery.setId(10);
    bookQuery.setId2(5);
    //lt 小于，le 小于等于
    //gt 大于，ge 大于等于
    //链式编程
    
    lqw.lt(null != bookQuery.getId(),Book::getId,bookQuery.getId());
    lqw.gt(null != bookQuery.getId2(),Book::getId,bookQuery.getId2());
    for (Book book : bookDao.selectList(lqw)) {
        System.out.println(book);
    }
    
    
    //查询结果包含模型中部分属性
    LambdaQueryWrapper lqw = new LambdaQueryWrapper();
    //查询id、书名、描述
    lqw.select(Book::getId,Book::getName,Book::getDescription);
    List bookList = bookDao.selectList(lqw);
    bookList.forEach(System.out::println);
    
    
    //查询结果包含模型中未定义的属性
    QueryWrapper qw = new QueryWrapper<>();
    
    qw.select("count(*) as nums,type");
    qw.groupBy("type");
    List> maps = bookDao.selectMaps(qw);
    System.out.println(maps);
    
    
    lqw.between(Book::getId,10,20);    //查询id在10到20之间，包含10和20
    lqw.like("计算机");			//like %计算机%
    lqw.likeLeft("计算机");		//like %计算机
    lqw.likeRigt("计算机");		//like 计算机%
}

4：映射匹配兼容性

@Data    //添加Lombok注解
@TableName("tbl_book")   //设置当前类与数据库表之间的对应关系
public class Book {
    private Integer id;
    @TableField(value = "type",select = false)   //value设置数据库表段名称，select：设置是否参与查询
    private String Type;
    private String name;
    private String description;

    @TableField(exist = false)   //设置属性在数据库表段中是否存在，默认为true，此属性无法与value合并使用
    private Integer isON;
}

• 全局配置

  mybatis-plus:
    global-config:
      db-config:
        id-type: auto    
        table-prefix: tbl_   
  

5：逻辑查询

5.1：数据库添加字段用于表示是否删除(注意尽量不要用关键字作为字段名)

5.2：用yml文件全局配置

mybatis-plus:
  global-config:
    banner: false
    db-config:
      logic-delete-field: is_delete   #设置表示逻辑删除的字段
      logic-delete-value: 1        #设置表示删除的值
      logic-not-delete-value: 0    #设置表示未删除的值

5.3：pojo类添加相应属性

// @TableLogic(value = "0",delval = "1")
private Integer is_delete;     //表示逻辑删除

5.4：执行删除操作

@Test
void deleteTest(){
    bookDao.deleteById(3);
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ku5rodfz-1653122017080)(SSM笔记.assets/image-20220521115510938.png)]

• 注意这时执行的是UPDATE操作
  Book::getId,Book::getName,Book::getDescription);
  List bookList = bookDao.selectList(lqw);
  bookList.forEach(System.out::println);

  //查询结果包含模型中未定义的属性
  QueryWrapper qw = new QueryWrapper<>();
  /* qw.select(“id”,“name”,“description”);
  for (Book book : bookDao.selectList(qw)) {
  System.out.println(book);
  } /
  qw.select("count() as nums,type");
  qw.groupBy(“type”);
  List> maps = bookDao.selectMaps(qw);
  System.out.println(maps);

  /-------------------------其他查询---------------------------------/
  lqw.between(Book::getId,10,20); //查询id在10到20之间，包含10和20
  lqw.like(“计算机”); //like %计算机%
  lqw.likeLeft(“计算机”); //like %计算机
  lqw.likeRigt(“计算机”); //like 计算机%
  }

###### 4：映射匹配兼容性

```java
@Data    //添加Lombok注解
@TableName("tbl_book")   //设置当前类与数据库表之间的对应关系
public class Book {
    private Integer id;
    @TableField(value = "type",select = false)   //value设置数据库表段名称，select：设置是否参与查询
    private String Type;
    private String name;
    private String description;

    @TableField(exist = false)   //设置属性在数据库表段中是否存在，默认为true，此属性无法与value合并使用
    private Integer isON;
}

• 全局配置

  mybatis-plus:
    global-config:
      db-config:
        id-type: auto    
        table-prefix: tbl_   
  

5：逻辑查询

5.1：数据库添加字段用于表示是否删除(注意尽量不要用关键字作为字段名)

5.2：用yml文件全局配置

mybatis-plus:
  global-config:
    banner: false
    db-config:
      logic-delete-field: is_delete   #设置表示逻辑删除的字段
      logic-delete-value: 1        #设置表示删除的值
      logic-not-delete-value: 0    #设置表示未删除的值

5.3：pojo类添加相应属性

// @TableLogic(value = "0",delval = "1")
private Integer is_delete;     //表示逻辑删除

5.4：执行删除操作

@Test
void deleteTest(){
    bookDao.deleteById(3);
}

• 注意这时执行的是UPDATE操作