SSM笔记-CSDN博客

本文链接：https://blog.csdn.net/The_Blue/article/details/127443728

Spring Framework

Core Container：核心容器
AOP：面向切面编程
Aspects：AOP思想实现
Data Access：数据访问
Data Integration：数据集成
Web：Web开发
Test：单元测试和集成测试

SF系统架构

核心容器

IoC：控制反转
- 使用对象时，由主动new产生对象转化为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想成为控制反转
Spring技术对IoC思想进行了实现
- Spring提供了一个容器，成为IoC容器，用来充当**“外部”**
- IoC容器负责对象的创建，初始化等一系列工作，被创建或者被管理的对象在IoC容器中统称为Bean
DI依赖注入
- 在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入
目标：充分解耦
- 使用IoC容器管理bean（IoC）
- 在IoC容器内将有依赖关系的bean进行关系绑定（DI）
最终效果
- 使用对象时不仅可以直接从IoC容器中获取，并且获取到的bean已经绑定了所有的依赖关系

IoC入门

导入Spring坐标即在pom.xml中添加前置

首先在pom.xml中添加Spring的依赖项spring-context

定义Spring管理的类（接口）
创建Spring配置文件，配置对应的类为Spring管理的bean

在resources右键->新建（new）->XML-> Spring 配置就新建了一个文件applicationContext.xml
在新建的文件中配置bean
- <bean id="name" class="位置.类名"/>

初始化IoC容器

ApplicationContext IoC_name = new ClassPathXmlApplicationContext("applicationContext.xml");

通过容器获取bean

类名 class_name = (类名) IoC_name.getBean("Bean_name");

DI入门

基于IoC管理bean

删除业务层中使用new方法放创建的对象
提供对应的setter方法
配置关系

public class Demo{

	private Demo2 demo2;   //定义了Demo类型没有new
	public void save() {
		demo2.save();
		System.out.println("hello Demo1");
	}
    
	//通过set方法实现,其实就是写了set方法，到时候IoC会给你创建一个Demo2类的东西丢到setDemo2里面
	public void setDemo2(Demo2 demo2) {
		this.demo2 = demo2;
	}
}

//=============================================================================

public class Demo2 {
    public void save(){
        System.out.println("this Demo2");
    }
}

配置中相应的操作：

如果bean中有多个类就多写几行就可以

 <bean id="name2" class="com.itheima.Demo2"/>

 <bean id="name1" class="com.itheima.Demo">
     <property name="demo2" ref="name2"/>
 </bean>

执行文件里面直接getBean就可以了：

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
Demo nn = (Demo) ctx.getBean("name1");
nn.save();

运行结果：

this Demo2
hello Demo1

Bean的配置

bean添加name参数可以增加别名
- <bean id=“name1” name=“别名1 别名2 …” class=“com.itheima.Demo”/>
- NoSuchBeanDefinitionException异常就是bean名字不存在
添加scope参数可设置对象是否为单例
- <bean id=“name1” class=“com.itheima.Demo” scope=“prototype”/>
- 默认单例，prototype非单例

构造方法实例化bean

构造方法

跟类同名的方法就是构造方法
bean采用反射，私有也可以访问
不可加参数
报错NoSuchMethodException，构造方法有参数
报错BeanCreationException，无参构造方法不存在(构造方法有参数)

静态工厂

//静态工厂 静态方法可以不通过对象调用
public class DamoFactory {
    public static Demo3 getDemo3(){
        return new Demo3();
    }
}

//Demo3
public class Demo3 {
    public void save3(){
        System.out.println("this is Demo3");
    }
}

//运行代码
public class Test2 {
    public static void main(String[] args) {

        Demo3 demo3 = DamoFactory.getDemo3();
        demo3.save3();
    }
}

/*输出结果
this is Demo3

配置bean

<bean id="name3"
      class="com.itheima.factory.DamoFactory" 
      factory-method="getDemo3" />

//然后就可以通过这个方法创建Demo3
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
Demo3 nn = (Demo3) ctx.getBean("name3");
nn.save3();

动态工厂

//动态工厂
public class DamoFactory {
    public Demo3 getDemo3(){
        return new Demo3();
    }
}

//Demo3
public class Demo3 {
    public void save3(){
        System.out.println("this is Demo3");
    }
}

//运行代码
public class Test2 {
    public static void main(String[] args) {

        DamoFactory damofactory = new DamoFactory(); //动态工厂要通过对象

        Demo3 demo3 = damofactory.getDemo3();
        demo3.save3();
    }
}

/*输出结果
this is Demo3

方法1

<bean id="df"
      class="com.itheima.factory.DamoFactory"/> <!--先配置工厂-->

<bean id="name4" 
      factory-bean="df"                   		
      factory-method="getDemo3"/>
<!--先配置工厂的bean，再配置方法-->

//然后就可以通过这个方法创建Demo3
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
Demo3 nn = (Demo3) ctx.getBean("name3");
nn.save3();

FactoryBean

//创建FactoryBean
//要实现泛型FactoryBean
public class DemoFactoryBean implements FactoryBean<D3> {

    public D3 getObject() throws Exception {
        return new Demo3();
    }

    public Class<?> getObjectType() {
        return D3.class;
    }

    //是否为单例
    public boolean isSingleton() {
        return true;
    }
}

配置bean

<bean id="name5" class="com.itheima.factory.DemoFactoryBean"/>

然后就可以通过bean获得Demo3类

bean的生命周期

关闭

//bean类型应为ClassPathXmlApplicationContext，才能用close(); 
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

//强制关闭
ctx.close();

//注册关闭钩子 虚拟机结束时自动关闭bean
ctx.registerShutdownHook();

配置

在实现的类中写相应函数，再进行相关配置

public class Demo3 implements D3{
    public void save3(){
        System.out.println("this is Demo3");
    }
    
    //创建函数
    public void init(){
        System.out.println("创建Demo3");
    }
    
    //销毁函数
    public void destory(){
        System.out.println("销毁Demo3");
    }
}

配置

<bean id="name5" 
      class="com.itheima.Demo3" 
      init-method="init" 
      destroy-method="destory"/>

自动

实现接口InitializingBean, DisposableBean即可，再生成相关函数

public class Demo3 implements D3, InitializingBean, DisposableBean {
    public void save3(){
        System.out.println("this is Demo3");
    }
    
	//生成
    public void destroy() throws Exception {
        System.out.println("创建");
    }
    
    //销毁，初始化设置后才会销毁
    public void afterPropertiesSet() throws Exception {
        System.out.println("销毁");
    }
}

DI

setter注入

简单类型引用类型

创建相关数据类型，提供setter方法，配置

public class Demo{
	
    //创建数据
	String a;
	int b;
	
    //配置setter
	public void setA(String a) {
		this.a = a;
	}

	public void setB(int b) {
		this.b = b;
	}

	public Demo() {
		System.out.println("Demo is starting");
	}
	private Demo2 demo2;   //定义了Demo类型没有new
	public void save() {
		demo2.save();
		System.out.println(a+" 学号:"+b);
	}
    
	//通过set方法实现
	public void setDemo2(Demo2 demo2) {
		this.demo2 = demo2;
	}

}

property中用value配置常量，ref配置引用

<bean id="name2" class="com.itheima.Demo2"/>

<bean id="name1" class="com.itheima.Demo">
        <property name="a" value="刘天阳"/>
        <property name="b" value="202112113"/>
        <property name="demo2" ref="name2"/>
</bean>

构造器注入
- 简单类型
- 引用类型
  
  创建构造函数，配置中property改为constructor-arg，其他同setter注入
  
  name可以改为type和index，后者分别对应类型和位置

自己写项目还是多用setter

自动装配

<bean id="name1" 
      class="com.itheima.Demo" 
      autowire="byType"/>

简单类型不可自动装配
byType是类型匹配，要求类型唯一
byName是名字匹配，匹配的是set方法里面的名字和配置文件中bean的名字

集合注入

语法：Spring 注入集合_w3cschool

加载properties文件

开启命名空间

替换为这个

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"

       xsi:schemaLocation="
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       ">

<context:property-placeholder location="classpath:*.properties"/>
${}占位符替换name=""引号中内容即可

补充

获取bean

注解开发

类前面标注@Component("name")
配置<context:component-scan base-package="com.itheima"/>就可以了，扫描文件
@Service 业务层

@Controller 数据层同 @Component("name")

纯注解开发

配置文件删除，换成配置类

@Configuration
@ComponentScan("com.itheima")
public class pz {
}

获取容器改为

 ApplicationContext ctx = new AnnotationConfigApplicationContext(SC.class);

作用范围

@Scope("singleton")

生命周期

@PostConstruc

@PreDestroy

注入

@Autowired自动注入可以不要set

@Qualifier指定加载

@Value("内容") 简单注入

@PropertySource("路径")加载property，不支持通配符，多文件用大括号

第三方bean
- @bean
- @import

整合

AOP

导入包spring-context，aspectjweaver
配置里面加@EnableAspectJAutoProxy

@Component
@Aspect

public class MyAdvice {
    //切入点
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    
    //绑定
    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

AOP通知

环绕

//AOP通知

@Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}

    //环绕通知
    @Around("pt()")
    public Object method(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("前");
        
        //执行原程序
        Object ret = pjp.proceed();
        System.out.println("后");
        return ret;
    }

	//前置通知
    @Before("pt()")

	//后置通知
    @After("pt()")

	//返回后通知
    @AfterReturning("pt()")

	//抛出异常后通知
    @AfterThrowing("pt()")

//获取执行签名信息
Signature signature = pjp.getSignature();

//获得方法名
signature.getName();

//获得执行类型(方法名)
signature.getDeclaringType();

AOP通知获取数据

获取参数

环绕通知用ProceedingJoinPoint，这个是JoinPoint的子类

@Around("pt()")
    public Object method(ProceedingJoinPoint pjp) throws Throwable {
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        Object[] ret = pjp.getArgs();
        return ret;
    }

其他用JoinPoint

@Before("pt()")
    public void method(JoinPoint jp){
        Object[] args = jp.getArgs();
        System.out.println(Arrays.toString(args));
    }

获取返回值

抛出异常后

@AfterReturning(value = "pt()",returning = "ret")
    public void method(String ret){
        System.out.println(ret);
    }

环绕，直接手写，ret就是返回值

@Around("pt()")
    public Object method(ProceedingJoinPoint pjp) throws Throwable {   
        Object ret = pjp.proceed();
        return ret;
    }

AOP总结

事务

事务作用：在数据层保障一系列的数据库操作同成功同失败
Spring事务作用：在数据层或业务层保障一些列的数据库操作同成功同失败
添加依赖

<dependency>
    <groupId>org.springframework</groupId>
	<artifactId>spring-tx</artifactId>
	<version>5.0.8.RELEASE</version>
</dependency>

给接口，类或者方法添加@Transactional,给谁添加就是给谁添加事务
bean

@Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }

给配置类添加@EnableTransactionManagement
事务管理员
事务协调员

家族

SpringMVC

配置SpringMVC

导入依赖，设置配置和插件

<!--pom.xml-->


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.itheima</groupId>
  <artifactId>SpringWeb</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.soure>1.8</maven.compiler.soure>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>


  <dependencies>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <port>80</port>
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

创建SpringMVC控制器类（等同于Servlet功能）

//UserController.java

//2.1 定义Controller
@Controller
public class UserController {
    //2.2 设置访问路径
    @RequestMapping("/save")
    //2.3 设置当前返回值类型
    @ResponseBody
    public String save(){
        System.out.println("user save ...");
        return "{'module':'springmvc'}";
    }
}

初始化SpringMVC环境（同Spring环境），设定SpringMVC加载对应的 bean

//SpringMvcConfig

@Configuration
@ComponentScan("com.itheima.controller")
@EnableWebMvc
public class SpringMvcConfig {
}

初始化Servlet容器，加载SpringMVC环境，并设置SpringMVC技术处理的请求

//ServletContainersInitConfig

public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    //加载SpringMVC容器配置
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringMvcConfig.class);
        return ctx;
    }
//    设置那些请求归属springMVC处理
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
//    加载spring容器配置
    @Override
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }

    //中文处理
@Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
    }

文件结构如下

一些注解

加载控制

语法

请求路径前缀

@RequestMapping("/save")可以放在类外面，类里面的就会自动在前面加上 /save

传参

Get请求

在控制类的方法中加相应参数即可

Post请求

也是在控制类的方法中加相应参数

Post乱码处理

 @Override
    protected Filter[] getServletFilters() {
        //字符集类型
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
    }

传参
- 名称前后匹配
- @RequestParam("name")进行对规则，可以设置默认值defaultValue，和是否为必传参数required = false
- POJO参数，用实体类接受参数
- - 嵌套POJO，被嵌套的类加前缀（所属类）即可
- 数组传参数组名对应即可
- 集合

json

接收数都据加上@ResponseBody即可

区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NMdbLmin-1666342820202)(C:\Users\15991\AppData\Roaming\Typora\typora-user-images\image-20221018153526258.png)]

日期类传递

@DateTimeFormat关键字的pattern

@RequestMapping("/dataParam")
    //2.3 设置当前返回值类型
    @ResponseBody
    public String sdatParam(Date date,
                            @DateTimeFormat(pattern = "yyyy-MM-dd") Date date1,
                            @DateTimeFormat(pattern = "yyyy/MM/dd HH.mm.ss") Date date2,
                            ){
        System.out.println("Date = " + date);
        System.out.println("Date2 = " + date2);
        System.out.println("Date3 = " + date3);
        return "{'module':'springmvc'}";
    }

响应

将对象数据转化成json

加上@ResponseBody，return就是输出了

REST方法

REST风格简洁

REST

快速开发

@RestController代替@Controller和@ResponseBody
@PostMapping 代替 请求 和 @RequestMapping，请求是Post，Get，Delete啥的
@ResponseBody放到大类外面

SSM

配置

	<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.6</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.16</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>

<build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <port>80</port>
          <path>/</path>
        </configuration>
      </plugin> 
    </plugins>
  </build>

SSM整合

数据统一返回到前端

设置统一数值返回结果类

public class Result {
        public Object data;
        public Integer code;
        public String msg;
    }

code设置数据统一返回码，有不同含义

根据情形设定合理的Result

异常处理器

@RestControllerAdvice 声明类是用来做异常处理的
@ExceptionHandler(Exception.class) 拦截异常类，处理全部异常

@RestControllerAdvice
public class ProjectExceptionAdvice {

    @ExceptionHandler(Exception.class)
    public Result doExpection(){
        System.out.println("Sir,this way!");
        return new Result(666, "这里有一个异常");
    }
}

异常处理

自定义系统/业务级的异常

自定义异常编码

触发自定义异常

拦截并处理异常（SystemException虽然不是异常类，但是是throw出来的，就可以触发@RestControllerAdvice，进而判断（类匹配）进入第一个，

放行网页的请求

创建一个新的配置类，并通过接口覆盖（alt+Ins）创建addResource方法

@Configuration //表示为配置类
public class SpringMvcSupport extends WebMvcConfigurationSupport {

    //这就是addResource方法
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
       	//这个表示访问到/dao我就给他转到/domain
        registry.addResourceHandler("/dao").addResourceLocations("/domain");
    }
}

拦截器

在控制器前后执行，

通过接口覆盖生成实现方法

public class ProjectIniterceptor implements HandlerInterceptor{

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    }

    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    }
}

拦截器配置，跟上面放行网页请求放在同一个配置类

@Autowired
    private ProjectIniterceptor projectIniterceptor;

    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(projectIniterceptor).addPathPatterns();
    }

拦截器参数

request 请求对象
response 响应对象
ex 异常

多拦截器

先进先出，终端会直接走后一个的after

SpringBoot

配置

创建新模块，选择Spring初始化，并配置模块相关基础信息
选择当前模块需要的技术集
开发控制器类
运行自动生成的Application类

配置文件

配置在.properties .yml 和. ymal

yaml数据格式记得在 : 后面加空格

yaml数据读取

记得将依赖添加到pom文件中

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
</dependency>

多环境配置

yml和ymal配置

spring:
  profiles:
    active: pro #指定启用环境

---
#设置生产环境
spring:
  profiles: pro
#生产环境参数设定
server:
  port: 80
---
#设置开发环境
spring:
  profiles: dev
#开发环境参数设定
server:
  port: 81
---
#设置测试环境
spring:
  profiles: test
#测试环境配置
server:
  port: 82

properties

设置 -> Encodings 都改成UTF-8
带参数启动SpringBoot

MybatisPlus

创建

勾选MySQL Driver依赖
要添加依赖

SpringBoot整合MybatisPlus启动依赖
<dependency>
      <groupId>com.baomidou</groupId>
      <artifactId>mybatis-plus-boot-starter</artifactId>
      <version>3.5.2</version>
</dependency>
<dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.16</version>
</dependency>

设置jdbc参数

配置yml即可

定义数据接口，继承BaseMapper<User>

User是类名

@Mapper
public interface UserDao extends BaseMapper<User>{
}

官网 MyBatis-Plus (baomidou.com)

数据层标准开发

语法

lombok依赖

<dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.12</version>
      <scope>provided</scope>
    </dependency>

@Getter
@Setter
@Data
public class User{
	private Long id;
	private String name;
	private String password;
	private Integer age;
}

@Data注解包括了对应的有参/无参构造方法，toString方法，hashCode方法，equla等

分页功能

先打开拦截器

@Configuration
public class MPConfig {
    
    @Bean
    public MybatisPlusInterceptor mpInterceptor(){
        //1 创建mpPlusInterceptor拦截器对象
        MybatisPlusInterceptor mpinterceptor=new MybatisPlusInterceptor();
        //2 添加分页拦截器
        mpinterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mpinterceptor;
    }
}

使用

       //1 创建IPage分页对象,设置分页参数,1为当前页码，3为每页显示的记录数
       IPage page=new Page(1,3);
       //2 执行分页查询
       userDao.selectPage(page,null);
       //3 查询
       System.out.println("当前页码："+page.getCurrent());
       System.out.println("每页显示总量："+page.getSize());
       System.out.println("总页数："+page.getPages());
       System.out.println("数据总量："+page.getTotal());
       System.out.println("当前页数据："+page.getRecords());

按条件查询

连着写默认是并且（and），或者加个or()

null处理

查询投影

就是查询的结果格式

条件查询

条件构造器 | MyBatis-Plus (baomidou.com)

语法

字表映射

模型类和数据库属性不对应 value=“…”
模型类属性不参与查询 select = flase
字段名和表名映射 @TableName(“…”)

在模型类属性上方添加@TableField(value="...",select = flase)

select = flase表示参与查询

@TableName("tab_user")
public class User{
	@TableField(value="pwd", select = flase)
	private String password;
}

id生成策略

可以用关键字@TableID(type = Type.AUTO)

全局配置
- id-type是id生成策略
- table-prefix是模型类要加上的前缀

多数据删除/查询

逻辑删除

数据库中添加相应的字段并附上默认值
在进行标记逻辑删除的类中的数据上添加@TableLogic，其值表示是否被删除
也可以进行全局配置，logic-delete-field是哪个字段名表示是否逻辑删除，not是没被删除，另一个是被删除

也就是说，如果deleted数值为0，表示这个数值还存储在在表中，而为1时，表示数据已经被删除

乐观锁

这个方法适用于2000一下的小请求

添加乐观锁标记字段
加个拦截器

@Configuration
public class MPConfig {
    
    @Bean
    public MybatisPlusInterceptor mppageInterceptor(){
        //1 创建mpPlusInterceptor拦截器对象
        mpMybatisPlusInterceptor interceptor=new MybatisPlusInterceptor();
        //2 添加分页拦截器
        mpinterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        //3 加乐观锁拦截器
        mpinterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return mpinterceptor;
    }
}

代码生成器

添加依赖

<!--代码生成器-->
<dependency>
     <groupId>com.baomidou</groupId>
     <artifactId>mybatis-plus-generator</artifactId>
     <version>3.4.1</version>
 </dependency>

<!--velocity模板引擎-->
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.3</version>
</dependency>

配置各种设置即可

FastAutoGenerator.create("url", "username", "password")
    .globalConfig(builder -> {
        builder.author("baomidou") // 设置作者
            .enableSwagger() // 开启 swagger 模式
            .fileOverride() // 覆盖已生成文件
            .outputDir("D://"); // 指定输出目录
    })
    .packageConfig(builder -> {
        builder.parent("com.baomidou.mybatisplus.samples.generator") // 设置父包名
            .moduleName("system") // 设置父包模块名
            .pathInfo(Collections.singletonMap(OutputFile.xml, "D://")); // 设置mapperXml生成路径
    })
    .strategyConfig(builder -> {
        builder.addInclude("t_simple") // 设置需要生成的表名
            .addTablePrefix("t_", "c_"); // 设置过滤表前缀
    })
    .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
    .execute();