Spring的基础知识

1.简介
- 1.2 优点：
- 1.3 组成七大部件
- 1.4 扩展
2、 IOC 理论推导
- 2.1 引言
- 2.2 IOC本质
- 2.3 控制反转
3. IOC创建对象的方式
- 3.1 使用无参构造创建对象，默认
- 3.2 有参构造创建对象有三种方式
- - 3.2.1 下标匹配方式 0 表示下标为0的参数（也就是第一个参数）
  - 3.2.2 参数类型匹配方式，不建议使用，两个string会冲突
  - 3.2.3 直接通过参数名匹配 ref
- 3.3 小总结
4. Spring配置
- 4.1 别名
- 4.2 bean的配置
- 4.3、 import
5. 依赖注入（DI）dependency injection
- 5.1 构造器注入
- 5.2 set方式注入【重点】
- - 5.2.1 依赖注入：set注入
- 5.3 拓展方式注入
- 5.4 bean的作用域：6种
- - 5.4.1 单例模式（spring默认机制）
  - 5.4.2 原型模式每一次从容器中get的时候，会产生新的对象
6.bean的自动装配
- 6.1 测试
- 6.2 ByName自动装配
- 6.3 ByType自动装配
- 6.4 使用注解实现自动装配
- - 6.4.1 @Autowired 注解
  - 6.4.2 @Resource 注解
7. 使用注解开发
8、使用Java方式配置Spring
- 8.1 配置类
- 8.2 实体类
- 8.3 测试类
9、代理模式
- 9.1 静态代理
- 9.2 加深理解
- 9.3 动态代理
10、AOP
- 10.1 AOP概念
- 10.2 AOP在Spring中的作用
- 10.3 使用Spring实现AOP
- 10.4 自定义类实现AOP
- 10.5 使用注解实现AOP
11、整合Mybatis
- 11.1 回忆Mybatis
- 11.2 MyBatis-Spring
- 11.3 SqlSessionDaoSuppor
12、声明式事务

Spring官网
Spring框架文档
Sping函数文档
Sping下载路径
Spring和Spring Boot之间的区别
Spring（IOC）

Spring框架是一个开放源代码的J2EE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。 Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与 Swing等桌面应用程序AP组合。因此， Spring不仅仅能应用于J2EE应用程序之中，也可以应用于桌面应用程序以及小应用程序之中。Spring框架主要由七部分组成，分别是 Spring Core、 Spring AOP、 Spring ORM、 Spring DAO、Spring Context、 Spring Web和 Spring Web MVC。

1.简介

Spring：春天----> 给软件行业带来了春天
2002，首次推出了Spring框架的出行：interface21框架
Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日正式发布1.0版本
Rod Johnson ,Spring Framework创始人，著名作者，很难想象Rod Johnson的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他不是计算机专业的，而是音乐学。
Spring理念：是现有的技术更加容易使用，本身是一个大杂烩。
SSH：Struct2 + Spring + Hibernate
SSM: SpringMVC + Spring + Mybatis
官网： https://spring.io/projects/spring-framework#overview

官方下载： https://repo.spring.io/release/org/springframework/spring/
GitHub： https://github.com/spring-projects/spring-framework

依赖：



    org.springframework
    spring-webmvc
    5.3.9


    org.springframework
    spring-jdbc
    5.3.9

1.2 优点：

spring是开源的免费的容器。
spring是一个轻量级的，非入侵式的框架。
控制反转（IOC），面向切面编程 (AOP)。
支持事务处理，对框架整合的支持。

OC和AOP简介

IOC：控制反转。
控制反转（Inversion of Control），又叫依赖注入（Dependency Injection）。简单来说，在未使用IOC之前，假如说有一个User类，要调用里面的方法（不是静态方法），就要new一个对象（如：User user=new User），然后进行调用。但对于Spring的IOC来说，把new对象这个过程交给了Spring来实现并进行管理，程序员只需要使用即可。
AOP：面向切面编程。
面向切面编程（Aspect Orient Programming）支持允许将一些通用的任务如安全、事务、日志、缓存等进行集中式处理，从而提供了更好的复用，AOP通常用来处理一些具有横切性质的系统级服务。

总结：spring是一个轻量级的控制反转(IOC)和面向切面编程(AOP)的框架。

1.3 组成七大部件

1.4 扩展

在Spring的官网有这个介绍：现代的java开发！说白了就是基于Spring的开发！

Spring Boot与Spring Cloud：

Spring Boot是 Spring 的一套快速配置脚手架，可以基于Spring Boot快速开发单个微服务;
Spring Cloud是基于Spring Boot实现的;
Spring Boot专注于快速、方便集成的单个微服务个体,Spring Cloud关注全局的服务治理框架;
Spring Boot使用了约束优于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置，Spring Cloud很大的一部分是基于Spring Boot来实现,，Spring Boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud离不开Spring Boot，属于依赖的关系。
SpringBoot在SpringClound中起到了承上启下的作用，如果你要学习SpringCloud必须要学习SpringBoot.

2、 IOC 理论推导 2.1 引言

UserDao
UserDaoImp 实现类
UserSevice 业务接口
UserServiceImp 业务实现类

在之前，用户的需求可能会影响原来的代码。

之前，程序是主动创建对象，控制权在程序员手上。

使用set注入之后，程序不再具有主动性，变成了被动的接收对象。

IOC思想，从本质上解决了问题，程序员不用再去管理对象的创建了，系统的耦合性降低，可以更加专注的业务层

这是IOC的原型，反转就是把主动权交给用户

所以，使用Spring的开发步骤如下：
（1）导入Spring使用需要的maven坐标
（2）创建Bean对象，即dao层和service层中的类
（3）创建applicationContext.xml文件
（4）在配置文件中进行配置
（5）创建ApplicationContext对象getBean()

2.2 IOC本质

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法.
没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制
控制反转后将对象的创建转移给第三方，获得依赖对象的方式反转了。
IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。
Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

2.3 控制反转

IOC

控制：谁来控制对象的创建，传统应用是由程序员控制对象的创建，使用spring后，对象是由spring来控制
反转：程序本身不创建对象，而变成被动的接收对象
依赖注入：就是利用set方法来进行注入

IOC是一种编程思想，由主动的编程变成被动的接收，可以通过ClassPathXmlApplicationContext 去浏览一下底层源码

现在，我们彻底不用在程序中改动了，要实现不同的操作，只需要在xml配置中进行修改。所谓的IOC：对象由spring进行创建、管理、装配

xml模板

3. IOC创建对象的方式

public class User {
    private int id;
    private String name;

    public User(int id,String name) {
        System.out.println("--------这是有参构造方法--------");
        this.id = id;
        this.name = name;
    }
	//。。。省略 get / set 方法

3.1 使用无参构造创建对象，默认

3.2 有参构造创建对象有三种方式 3.2.1 下标匹配方式 0 表示下标为0的参数（也就是第一个参数）

3.2.2 参数类型匹配方式，不建议使用，两个string会冲突

3.2.3 直接通过参数名匹配 ref

3.3 小总结

在配置文件加载的时候，所有的bean就已经被实例化了，要用直接去get就可以了

内存中只有一份实例

    public static void main(String[] args) {
    	//绑定完配置文件，bean就已经被实例化了
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        User user = (User) context.getBean("user");
        user.show();
        System.out.println(user);
    }

4. Spring配置 4.1 别名

4.2 bean的配置

4.3、 import

这个import，一般用于团队开发使用，他可以将多个配置文件，导入合并为一个

applicationContext.xml

5. 依赖注入（DI）dependency injection 5.1 构造器注入

前面讲过了

5.2 set方式注入【重点】 5.2.1 依赖注入：set注入

依赖： bean对象的创建依赖于容器
注入： bean对象中的所有属性，由容器来注入

【环境搭建】

复杂类型

public class Address {

    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

真实测试对象

    private String name;
    private Address address;
    private String[] books;
    private List hobbys;
    private Map card;
    private Set games;
    private String wife;
    private Properties info;

beans.xml

测试类

public class MyTest {
    public static void main(String[] args) {
            ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        Student student = (Student) context.getBean("student");

        System.out.println(student.toString());
        
    }
}

5.3 拓展方式注入

我们可以使用 P命名空间和 C命名空间注入

注意：需要导入xml约束

	xmlns:p="http://www.springframework.org/schema/p"

	xmlns:c="http://www.springframework.org/schema/c"

5.4 bean的作用域：6种

singleton：全局只能有1个
prototype：每一个变量都有一个自己的

以下的只能在web中使用：

request
session
application
websocket

5.4.1 单例模式（spring默认机制）

    @Test
    public void test(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("userbean.xml");
        User user = (User) context.getBean("user2",User.class);
        User user2 = (User) context.getBean("user2",User.class);
        System.out.println(user==user2);
    }
    //结果为:true

5.4.2 原型模式每一次从容器中get的时候，会产生新的对象

	@Test
    public void test(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("userbean.xml");
        User user = (User) context.getBean("user2",User.class);
        User user2 = (User) context.getBean("user2",User.class);
        System.out.println(user==user2);
    }
    //结果为：false

6.bean的自动装配

自动装配是spring满足bean依赖的一种方式
spring会在上下文中自动寻找，并自动给bean装配属性

在spring中有三种装配方式：

在xml中显示的配置
在Java中显示的配置
隐式的自动装配bean【重要】

6.1 测试

【环境搭建】

一个人有两只宠物！

6.2 ByName自动装配

6.3 ByType自动装配

小结：
byname：需要保证所有bean的ID唯一，并且这个bean需要和自动注入的属性的set方法的值一致
bytype：需要保证所有bean的class唯一，并且这个bean需要和自动注入的类型一致。

6.4 使用注解实现自动装配

使用注解自动装配

jdk1.5支持的注解，spring2.5支持的注解

The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.

使用注解须知：

1、导入约束：context约束
2、配置注解的支持：context:annotation-config/

6.4.1 @Autowired 注解

在属性上个使用，也可以在set上使用
我们可以不用编写set方法，前提是你自动装配的属性在IOC容器中，且符合名字byname

科普：

@Nullable  字段标记了这个注解，说明这个字段可以为null   
//例如：
    public People(@Nullable String name) {
        this.name = name;
    }

源码：

public @interface Autowired {
    boolean required() default true;
}

@Autowired(required = false)
//说明这个对象可以为null，否则不允许为空，即使为null也不会报错

测试代码：

public class People {
    //说明这个对象可以为null，否则不允许为空，即使为null也不会报错
    @Autowired(required = false)
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;
}

如果@Autowired自动装配环境比较复杂。自动装配无法通过一个注解完成的时候

我们可以使用@Qualifier(value = “dog”)去配合使用，指定一个唯一的id对象

public class People {
    @Autowired
    private Cat cat;
    @Autowired
    @Qualifier(value = "dog222")
    private Dog dog;
    private String name;
}

6.4.2 @Resource 注解

public class People {

    @Resource(name = "cat2")
    private Cat cat;
    @Resource
    private Dog dog;
}

小结：

@Resource和@Autowired的区别：

都是用来自动装配的，都可以放在属性字段上
@Autowired 默认通过byType的方式实现，当匹配到多个同类型时，使用byname进行装配
@Resource 默认通过byname的方式实现，如果找不到名字，则通过byType方式实现
执行顺序不同：@Autowired 默认通过byType的方式实现，@Resource 默认通过byname的方式实现

7. 使用注解开发

确定已经导入aop的包
增加注解支持aop

bean

//@Component 组件
//等价于

@Component
public class User {
    public String name;
}

属性如何注入

@Component
public class User {
    
    public String name;
    @Value("hardy")
    //相当于
    public void setName(String name) {
        this.name = name;
    }
}

衍生的注解

@Component 有几个衍生的注解，我们在web开发中，会按照mvc三层架构分层

dao 【@Repository】
service 【@Service】
controller 【@Controller】

这四个注解功能都是一样的，都是代表将某个类注册到spring容器中，装配bean

自动装配置

- @Autowired：自动装配通过类型，名字
  如果autowired不能唯一自动装配上属性，则需要通过
- @Qualifier(value = "xxx")
- @Resource：自动装配通过名字，类型
- @Nullable：字段标记了这个注解，说明这个字段可以为null

作用域

@Component
@Scope("prototype")
public class User {

    public String name;
    @Value("hardy")
    //相当于
    public void setName(String name) {
        this.name = name;
    }
}

小结

xml与注解：
- xml 更加万能，适用于任何场合，维护简单方便
- 注解不是自己的类使用不了，维护相对复杂
xml与注解的最佳实践：
- xml用来管理 bean，注解只负责完成属性的注入
- 生产过程中：唯一需要注意，想让注解生效，就必须开启注解的支持

8、使用Java方式配置Spring

我们现在要完全不使用Spring的xml配置了，全权交给 java 来做！
JavaConfig是Spring的一个子项目，在Spring 4之后，它成为了一个核心功能！

8.1 配置类

@Configuration

@ComponentScan("com.hardy")
@Import(HardyConfig2.class)
public class HardyConfig {

    //注册一个bean  
    //id 就是方法名  
    //class属性  就是方法的返回值
    @Bean
    public User getUser(){
        return new User();
    }
}

8.2 实体类

@Component
public class User {
    private  String name;
    public String getName() {
        return name;
    }
   	//value对应  标签中的 property -- value
    @Value("hardy")
    public void setName(String name) {
        this.name = name;
    }
}

8.3 测试类

public class MyTest {
    public static void main(String[] args) {
        //如果完全使用了配置类方式去做，我们就只能通过AnnotationConfig 上下文来获取容器，
        // 通过配置类的class对象加载。
        ApplicationContext context = new AnnotationConfigApplicationContext(HardyConfig.class);
        User user = (User) context.getBean("getUser");//配置类的id名就是方法名
        System.out.println(user.getName());
    }
}

9、代理模式

为什么要学习代理模式？因为这就是Spring AOP的底层【Spring AOP 和 Spring MVC】必问

代理模式的分类：

静态代理
动态代理

9.1 静态代理

角色分析：

抽象角色：一般会使用接口或者抽象类来解决
真实角色：被代理的角色
代理角色：代理别人的角色，里面处理一些业务
客户：访问代理对象的人

步骤：

接口

//租房
public interface Rent {
    public void rent();
}

真实角色

public class Host implements Rent{
    @Override
    public void rent() {
        System.out.println("房东要出租房子");
    }
}

代理角色

public class Proxy implements Rent{
    // 代理角色第一件事，找房东搭伙  先用组合，少用继承（有局限）
    private Host host;//组合

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        contract();
        fare();
    }

    //看房
    public void seeHouse(){
        System.out.println("中介带你看房");
    }

    //签合同
    public void contract(){
        System.out.println("签租赁合同");
    }

    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

客户端访问代理

public class Client {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //中介
        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

代理模式的好处：

可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共业务交给代理角色，实现业务分工
公共业务发生扩展时，方便集中管理

缺点：

一个真实角色就会产生一个代理角色：代码量会翻倍，开发效率变低

9.2 加深理解

9.3 动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的
动态代理分为两大类：基于接口的动态代理、基于类的动态代理
- 基于接口----JDK动态代理
- 基于类：cglib
- java字节码实现：javasist 【常用】

需要了解两个类：Proxy：代理，InvocationHandler：调用处理程序

proxy 这个类用来动态生成代理对象
InvocationHandler 用来处理业务

模板

public class ProxyInvocationHandler implements InvocationHandler {
    //与业务接口组合
    private Object Target;
    //set方法 注入业务
    public void setTarget(Object target) {
        Target = target;
    }

    //生成代理类
    //获取当前类的加载器，获取业务的接口，当前对象
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                Target.getClass().getInterfaces(),this);

    }

    //处理业务，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //niubi
        log(method.getName());
        Object result = method.invoke(Target, args);
        return result;
    }

    //添加日志
    public void log(String msg){
        System.out.println("[debug]调用了"+msg+"方法");
    }
}

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色，不存在，找他的处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();

        pih.setTarget(userService);//设置要代理的对象
        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();

        proxy.delete();
    }
}

动态代理的好处：

可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共业务交给代理角色，实现业务分工
公共业务发生扩展时，方便集中管理
一个动态代理类代理的一个接口，一般就是对应的一类业务
一个动态代理类可以代理多个类，只要是实现了同一个接口即可

10、AOP 10.1 AOP概念

AOP(Aspect Oriented Programming)面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延伸，是Spring框架中的一个重要内容，也是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，降低耦合性，提高可用性

10.2 AOP在Spring中的作用

提供声明式事务；允许用户自定义切面

横切关注点：跨越应用程序多个模块的方法或功能。就是于业务逻辑无关，但需要关注的部分，比如日志、安全、缓存、事务。。
切面（Aspect）：横切关注点被模块化的特殊对象（一个类）
通知（Advice）：切面需要完成的工作（类中的一个方法）
目标（Target）：被通知对象
代理（proxy）：向目标对象应用通知之后创建的对象
切入点（pointCut）：切面通知执行的地点的定义
连接点（JoinPoint）：与切入点匹配的执行点

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：

通知类型	连接点	实现接口
前置通知	方法前	org.springframework.aop.MethodBeforeAdvice
后置通知	方法后	org.springframework.aop.AfterReturningAdvice
环绕通知	方法前后	org.aopalliance.intercept.MethodInterceptor
异常抛出通知	方法抛出异常	org.springframework.aop.ThrowsAdvice
引介通知	类中增加新的方法属性	org.springframework.aop.IntroductionInterceptor

10.3 使用Spring实现AOP

使用AOP织入，需要导入依赖包


    
        org.aspectj
        aspectjweaver
        1.9.4

创建Service接口和实现类

//接口
public interface UserService {
    public void add();
    public String delete();
    public void update();
    public void select();
}
//实现类
public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("add");
    }
    public String delete() {
        System.out.println("delete");
        return "删除了一条数据";
    }
    public void update() {
        System.out.println("update");
    }
    public void select() {
        System.out.println("select");
    }
}

log类

//在方法调用之前执行
public class BeforeLog implements MethodBeforeAdvice {

    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("before----------------------"+method.getClass().getName()+"类,执行了"+method.getName()+"方法");
    }
}

//方法调用之后执行
public class AfterLog implements AfterReturningAdvice {
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("after-------"+method.getClass().getName()+"类,执行了"+method.getName()+"方法,返回值是----"+returnValue);
    }
}

Spring核心配置文件

测试类

@Test
public void testLogAdd(){
    ApplicationContext context = new ClassPathXmlApplicationContext("application-context.xml");
    //动态代理代理的是接口
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();
}

@Test
public void testLogDelete(){
    ApplicationContext context = new ClassPathXmlApplicationContext("application-context.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.delete();
}

10.4 自定义类实现AOP

自定义类：

public class DiyPointCut {
    public void before(){
        System.out.println("========方法执行前=========");
    }
    public void after(){
        System.out.println("========方法执行后=========");
    }
}

xml配置

10.5 使用注解实现AOP

自定义类，添加注解：

@Aspect
public class AnnotationAspect {
    @Before("execution(* com.kuang.service.UserService.*(..))")
    public void before(){
        System.out.println("方法执行前-------------------");
    }

    @After("execution(* com.kuang.service.UserService.*(..))")
    public void after(){
        System.out.println("-------------------方法执行后");
    }

    @Around("execution(* com.kuang.service.UserService.*(..))")
    public void around(ProceedingJoinPoint pj) throws Throwable {
        System.out.println("----环绕前----");

        Signature signature = pj.getSignature();//获得签名
        System.out.println("方法签名："+signature);

        pj.proceed();//执行方法(必须显示调用，否则方法不执行)
        
        System.out.println("----环绕后----");
    }
}

xml文件配置：

执行结果：

----环绕前----
方法签名：String com.kuang.service.UserService.delete()
方法执行前-------------------
delete
-------------------方法执行后
----环绕后----

11、整合Mybatis 11.1 回忆Mybatis

导入相关jar包

Junit
mybatis
MySQL
spring相关
aop织入
mybatis-spring 【new】


    junit
    junit
    4.11



    mysql
    mysql-connector-java
    8.0.29



    org.mybatis
    mybatis
    3.5.10



    org.springframework
    spring-jdbc
    5.3.20



    org.aspectj
    aspectjweaver
    1.9.9.1



    org.mybatis
    mybatis-spring
    2.0.7


    org.springframework
    spring-webmvc
    5.3.20

Maven静态资源导出问题


    
        
            src/main/java
            
                ***.xml
            
            false
        
        
            src/main/resources
            
                ***.xml
            
            false

实体类

@Data
public class User {
    private int id;
    private String userName;
    private String userPwd;
}

Mapper接口

public interface UserMapper {
    //根据id查询用户
    User getUserById(int id);
}

Mapper.xml

配置文件


driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/stu?useSSL=false&useUnicode=true&characterEncoding=UTF-8
username=root
password=123456

MybatisUtils工具类：

public class MybatisUtils {
    
    private static SqlSessionFactory sqlSessionFactory;

    static{
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream,"development");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

测试：

@Test
public void getUser(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User userById = mapper.getUserById(1);
    System.out.println(userById);
}

11.2 MyBatis-Spring

编写数据源配置
sqlSessionFactory
sqlSessionTemplete

mybatis-spring.xml

Spring的基础知识

Java相关栏目本月热门文章