Spring5

Spring

- - 以下内容仅为了方便复制
IOC
- 作用
- 工作原理
1. 类注解@Component
- @Component设置实例名
2. 成员注解：注入基本数据类型与引用类型
- 1. @Value：注入基本数据类型
- 2. @Autowired：引用类型注入
- 3. 注解@Qualifier("对象名")通过对象名注入
- 4. 父子类注入
- 5. 其他注解
AOP:AspectJ框架
- - - 以下内容仅为了方便复制
- 1. 基本介绍
- - 1.1 通知类型（四种）
  - 1.2 切入点表达式
  - 1.3 切入点表达式别名@Pointcut
- 2. 前置通知@Before
- 3. 后置通知@AfterReturning
- 4. 环绕通知@Around
- 5. 最终通知@After
- 6. 所有通知的执行顺序
Spring集成Mybatis
- 1. 创建项目
- - 1.1 配置pom.xml
  - 1.2 Mybatis全局配置
  - 1.3 Spring接管MyBatis的配置文件
  - 1.4 MyBatis的配置文件与Spring接管后的配置文件对比
  - 1.5 Sping配置
  - 1.6 Mybatis：mapper.xml
Spring概念性的东西
IOC（控制反转）

以下内容仅为了方便复制

依赖

<!--    spring依赖--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.5.RELEASE</version></dependency>

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<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/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"><context:component-scan base-package="全限定包名"></context:component-scan>
</beans>

注解

//类注解
@Component

// 基本类型，默认值
@Value("张三")

// 引用类型
@Autowired

IOC

作用

自动创建类对象
Spring中整合和很多其他框架，Sping会自动调用类对象来完成某些功能。

工作原理

sping 读取并解析配置文件（例如：springConfig.xml文件），xml中指定了①要被实例化的全限定类名②实例化以后的名字③实例化对象的属性和属性值
通过反射机制，按照配置文件中指定的类创建对象，并使用类中的set方法给对象的属性注入值
使用注解后，配置文件基本没用，全部使用反射机制，通过注解指定类实例化的名字和属性的值

1. 类注解@Component

作用：Spring配置文件中设置包扫描，使用@Component注解的类都会被创建对象，对象的默认名称与类名相同且以驼峰命名法命名。
示例
1. 目录结构：

代码部分：
student1类

@Component // 在spring的配置文件中添加包扫描后，有此注解的类才会被创建对象
public class Student1 {private String name;private Integer age;public Student1() {System.out.println("Student1的构造函数执行");}@Overridepublic String toString() {return "Student1{" +"name='" + name + '\'' +", age=" + age +'}';}
}

配置文件
- 扫描s01目录，加@Component注解的类会被spring创建对象

<?xml version="1.0" encoding="UTF-8"?>
<beans ........>
<!--        扫描s1目录，加@Component注解的类会被spring创建对象--><context:component-scan base-package="org.example.s1"></context:component-scan>
</beans>

测试方法
- 在实体类Student1的注解中没有指定对象的名字，默认创建与类名相同且以驼峰命名法命名的对象名student1

    @Testpublic void test1(){ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext1.xml");// 注解中没有指定对象的名称，默认创建与类名相同且以驼峰命名法命名的对象名Student1 student1 = (Student1) ac.getBean("student1");System.out.println(student1);}

输出：

Student1的构造函数执行
Student1{name='null', age=null}

@Component设置实例名

@Component(“对象名称”)：指定Spring创建对象的名称

示例

代码
- 设置了对象名和初始值

@Component("stu") // 指定对象名
public class Student1 {private String name;private int age;
}

测试方法
- Student1的注解指定对象名：stu

    @Testpublic void test1(){ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext1.xml");// 注解中指定对象名Student1 student1 = (Student1) ac.getBean("stu");System.out.println(student1);}

输出

Student1的构造函数执行
Student1{name=null, age=null}

2. 成员注解：注入基本数据类型与引用类型

1. @Value：注入基本数据类型

无论是什么基本类型，都在引号内。int类型也在引号内@Value(“11”)

    @Value("张三") // 初始值private String name;

2. @Autowired：引用类型注入

类中成员的类型为引用类型时，注入时使用@Autowired注解，Spring会在对象工厂中查找该引用类型及其子类

示例
1. 目录结构
在这里插入图片描述
2. 代码
Student2类：

@Component
public class Student2 {@Value("张三")private String name;@Value("33")private int age;// 默认注入的引用类型为School2及其子类，会在Spring的建造工厂查找School2类型相同的对象注入@Autowiredprivate School2 school;public Student2() {System.out.println("Student2构造函数执行");}
}

School2类：

@Component
public class School2 {@Value("清华大学")private String schoolName;@Value("北京市海淀区")private String schoolAddress;public School2() {System.out.println("School2的构造函数执行");}
}

Spring配置文件

<context:component-scan base-package="org.example.s2"></context:component-scan>

测试方法

    @Testpublic void test2(){ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext2.xml");Student2 student2 = (Student2)ac.getBean("student2");System.out.println(student2);}

输出

School2的构造函数执行
Student2构造函数执行
Student2{name='张三', age=33, school2=School2{schoolName='清华大学', schoolAddress='北京市海淀区'}}

3. 注解@Qualifier(“对象名”)通过对象名注入

配合@Autowired使用，引用类型注入时，通过对象名在Sping对象工厂中查找并注入

示例

School2类

@Component("sch")
public class School2 {@Value("清华大学")private String schoolName;@Value("北京市海淀区")private String schoolAddress;public School2() {System.out.println("School2的构造函数执行");}

Student2类

@Component
public class Student2 {@Value("张三")private String name;@Value("33")private int age;// 通过对象名注入引用类型@Autowired@Qualifier("sch")private School2 school;public Student2() {System.out.println("Student2构造函数执行");}
}

Sping配置

<context:component-scan base-package="org.example.s2"></context:component-scan>

测试

    @Testpublic void test2(){ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext2.xml");Student2 student2 = (Student2)ac.getBean("student2");School2 sch = (School2) ac.getBean("sch");System.out.println("sch对象："+sch);System.out.println("student2对象"+student2);}

输出

School2的构造函数执行
Student2构造函数执行
sch对象：School2{schoolName='清华大学', schoolAddress='北京市海淀区'}
student2对象Student2{name='张三', age=33, school2=School2{schoolName='清华大学', schoolAddress='北京市海淀区'}}

4. 父子类注入

通过类型注入可能会搞混，建议通过名称注入

当注入类型有子类时，意味着可注入的类型有多个，此时会按照对象名称进行二次筛选，选中与被注入对象的名称相同的对象注入。

示例（伪代码）

student类：

@Component
public class Student{@Autowiredprivate School school;
}

School类：

@Component
public class School

SubSchool类（School的子类）：

@Component
public class SubSchool extend School

执行过程

首先会创建3个类的对象，对象的名称为类名的驼峰命名：student、school、subSchool
当sutdent对象的成员school需要注入时，会找到school和subSchool两个同源类型的对象
二次筛选，先找类型，类型相同，再找名字：比较难以描述。重点，容易搞混
举例：如果Student类中的成员private School school，则会找school对象，如果是private School subSchool，则会找subSchool对象。

5. 其他注解

@Component注解是spring最早使用的标注类要交给容器管理的注解

还有以下注解：
@Controller 对Controller层类进行标注（主要接受处理URL）
@Service 对Service层的类进行标注（是进行业务处理）
@Repository 对DAO层实现类进行标注（和数据库打交道的类）

后三个都是Component注解的别名，功能是一样，可以互换，为了区分被注解标注的类在不同的业务层，使逻辑更清晰

AOP:AspectJ框架

以下内容仅为了方便复制

依赖

<!--    添加spring依赖--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.5.RELEASE</version></dependency>
<!--   aspects依赖 --><dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>5.2.5.RELEASE</version></dependency>

sping配置文件

<?xml version="1.0" encoding="UTF-8"?>
<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"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"><context:component-scan base-package="完全限定包名"></context:component-scan><!--    切面与方法绑定--><aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

注解

XML配置文件中绑定目标方法和切面方法：<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
切面类注解：

@Aspect
@Component

前置通知：@Before(value = "execution(切入点表达式)")
后置通知：@AfterReturning(value = "execution(* com.springaspects.s2.*.*(..))",returning = "obj")
最终通知：@After
切入点表达式别名：@Pointcut
环绕通知：基本为固定写法

    @Around(value = "execution(* com.springaspects..*(..))")public Object myAround(ProceedingJoinPoint pjp) throws Throwable {//Todo 目标方法执行前可执行的代码Object obj = pjp.proceed(pjp.getArgs());//执行目标方法，返回值为obj//Todo 目标方法执行后可执行的代码return obj;//返回值可随意修改}

犯过的错误：
3.1 记得创建切面类的对象。切面类也需要@Component注释
3.2 创建配置文件，按下图。不要自己创建空白文件，在读取配置文件时文件后缀可能会搞错

1. 基本介绍

是一个面向切面的框架

1.1 通知类型（四种）

前置通知@Before
后置通知@AfterReturning
环绕通知@Around
最终通知@After
定义切入点@Pointcut（了解）

1.2 切入点表达式

标准公式：execution（访问权限方法返回值类型方法声明（参数）异常类型）
访问权限与异常类型可简化：execution（方法返回值类型方法声明（参数））

可使用符号：

* ：可代替任意个字符（通配符）
..：①出现在路径中，代表本路径及其所有的子路径；②出现在方法的参数中，代表任意参数。

示例

execution(pubulic * *(..))访问权限为public的任意方法
execution(* set*(..)):以set开头的任意方法
execution(* com.xyz.service.impl.*.*(..)):com.xyz.service.impl包下任意类中的所有方法
execution(* com.xyz.service..*.*(..)):com.xyz.service路径下任意子路径的任意类的任意方法

1.3 切入点表达式别名@Pointcut

具体使用，参照：6.所有通知的执行顺序

定义别名，在其他通知中用pointCut()就可以代替execution(* com.springaspects.s5.SomeServiceImpl.*(..))

    // 切入点表达式起别名@Pointcut(value = "execution(* com.springaspects.s5.SomeServiceImpl.*(..))")public void pointCut(){}

使用，value的值为上述的方法

    // 前置通知@Before(value = "pointCut()")public void myBefore(JoinPoint jp){System.out.println("前置通知，执行.....");}

2. 前置通知@Before

目标方法的类必须通过接口实现
切面类注解：@Aspect
前置切面方法的注解：@Before(value = "execution(切入点表达式)")
前置切面方法的参数JoinPoint:可获得目标方法的签名和传入的参数值

目录结构
代码部分

接口与接口实现类

public interface SomeService {String doSome(String name,int age);
}

public class SomeServiceImpl implements SomeService{public String doSome(String name, int age) {System.out.println("目标方法执行...........");return "success";}
}

切面类，前置通知方法
切入点表达式指向了非常明确的一个目标方法

@Aspect
public class S1Aspect {/*** 前置切面方法* 1. 访问权限为public* 2. 方法的返回值为void* 3. 方法名自定义* 4. 方法没有参数，有也只能是JoinPoint类型*      通过JoinPoint可获得目标方法的签名和参数的值等信息。签名：返回值类型+包路径+方法名+参数类型* 5. 必须使用@Before注解来声明切入的时机*      参数：value 指定切入点表达式* 目标方法：public String doSome(String name, int age)*/@Before(value = "execution(public String doSome(String,int))")public void myBefore(JoinPoint jp){// 获得目标方法的签名System.out.println(jp.getSignature());//String com.springaspects.s1.SomeService.doSome(String,int)// 获得目标方法的参数值System.out.println(Arrays.toString(jp.getArgs()));//[张三, 10]System.out.println("前置切面方法执行.....");}
}

spring的xml配置文件
使用最原始的创建对象的方式，没有使用注解的方式

<beans ......>
<!--       目标类对象--><bean id="someServiceImpl" class="com.springaspects.s1.SomeServiceImpl"></bean>
<!--    切面类的对象--><bean id="s1Aspect" class="com.springaspects.s1.S1Aspect"></bean>
<!--    绑定目标方法和切面方法--><aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

测试方法
一定要把实现类对象的类型强转为接口类型

    @Testpublic void test01(){ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext01.xml");//实体类对象强转为接口类型SomeService someService = (SomeService) ac.getBean("someServiceImpl");System.out.println(someService.getClass());//class com.sun.proxy.$Proxy9String s = someService.doSome("张三", 10);System.out.println("目标对象的返回值 = " + s);}

输出

class com.sun.proxy.$Proxy9
前置切面方法执行.....
目标方法执行...........
目标对象的返回值 = success

3. 后置通知@AfterReturning

和前置通知差不多，区别就是执行的时机不同，参数的作用不同
使用注解：@AfterReturning
后置通知的参数为目标方法的返回值。
后置通知的参数名称必须与注解中returning的值一致
后置通知的参数类型最好使用Object，在不确定目标方法的时候，目标方法的返回值类型也不确定
如果目标方法的返回值为引用类型时，可以在后置通知中修改目标方法的返回值

目录结构
代码部分

接口与实现类

public interface SomeService {String doSome(String name, int age);
}

@Service
public class SomeServiceImpl implements SomeService {public String doSome(String name, int age) {System.out.println("目标方法执行..........");return "success";}
}

切面类

@Aspect
@Component
public class MyAspect {/*** 1. 访问权限：public* 2. 方法没有返回值：void* 3. 方法名自定义* 4. 方法参数是目标方法的返回值。此参数可有可无，看需求。*      （当目标方法的返回值为引用类型时，可以修改返回值的内容，当返回值为普通类型时，修改了也没用）* 5. 使用@AfterReturning注解表明此方法的切入时机为后置*      参数：value 与@After的相同*           returning：指定目标方法的返回值的名称，此名称必须与切面方法的参数名称一致。* */// s2包下任意方法@AfterReturning(value = "execution(* com.springaspects.s2.*.*(..))",returning = "obj")public void myAfterReturning(Object obj){//参数的名称与注解中returning的值必须一致System.out.println("后置切面方法执行");System.out.println("后置切面方法中，目标方法的返回值 = "+ obj.toString());}
}

sping的xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans .....><!--    使用注解的方式创建对象，创建的对象的名称默认为类的驼峰命名法--><context:component-scan base-package="com.springaspects.s2"></context:component-scan><!--    绑定切面方法与目标方法--><aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

测试方法

    @Testpublic void test02(){ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContextS02.xml");SomeService someService = (SomeService) ac.getBean("someServiceImpl");String s = someService.doSome("李四", 11);System.out.println("绑定切面对象后，目标对象的返回值 = " + s);}

输出

目标方法执行..........
后置切面方法执行
后置切面方法中，目标方法的返回值 = success
绑定切面对象后，目标对象的返回值 = success

4. 环绕通知@Around

环绕通知与前置和后置通知有很大的不同，主要体现在参数和返回值部分
使用注解：@Around
参数部分：参数类型为ProceedingJoinPoint，proceed()方法相当于执行目标方法，getArgs()方法获取目标方法的参数
在示例中：pjp.proceed(pjp.getArgs())相当于在执行目标方法
返回值：建议返回值类型设置为Object，可随意修改目标方法的返回值

目录结构
代码部分

1.接口与实现类

public interface SomeService {String doSome(String name,int age);
}

@Component
public class SomeServiceImpl implements SomeService{public String doSome(String name, int age) {System.out.println("目标方法执行...........");return "success";}
}

切面类

@Aspect
@Component
public class MyAspect {/*** 1. 访问权限：public* 2. 返回值为目标方法的返回值，并且可疑任意修改* 3. 方法名自定义* 4. 参数必须有：参数类型为ProceedingJoinPoint，传入的是目标方法* 5. 回避异常* 6. 使用@Around注解声明此方法的切入时机为环绕*      参数：value：切入点表达式* */@Around(value = "execution(* com.springaspects..*(..))")public Object myAround(ProceedingJoinPoint pjp) throws Throwable {System.out.println("环绕通知：前置方法........");Object obj = pjp.proceed(pjp.getArgs());System.out.println("环绕通知：后置方法........");obj = "sssssss";return obj;}
}

sping配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans .....><context:component-scan base-package="com.springaspects.s3"></context:component-scan><aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

测试方法

    @Testpublic void test03(){ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContextS03.xml");SomeService someService = (SomeService) ac.getBean("someServiceImpl");String s = someService.doSome("王五", 13);System.out.println("环绕通知返回值 = " + s);}

输出

环绕通知：前置方法........
目标方法执行...........
环绕通知：后置方法........
环绕通知返回值 = sssssss

5. 最终通知@After

最终通知：无论目标方法发生任何异常都会被执行，类似于异常处理中的finally
使用注解：@After

目录结构与其他代码与前面基本相同

最终通知的代码

@Aspect
public class MyAspect {/*** 1. 访问权限：public* 2. 返回值：void* 3. 方法名自定义* 4. 参数非必要，如果有则为JoinPoint* 5. 使用@After注解声明此方法的切入时机为最终*      参数：value：切入点表达式* 6. 无论目标方法是否正常执行完毕，最终通知都会执行* */@After(value = "execution(* com.springaspects.s4.SomeServiceImpl.*(..))")public void myAfter(){System.out.println("最终通知执行..........");}
}

返回值

目标方法执行...........
最终通知测试 = success

6. 所有通知的执行顺序

运行结果：

环绕通知：前置方法........
前置通知，执行.....
目标方法执行...........
环绕通知：后置方法........
最终通知，执行..........
后置通知，执行.....
测试方法：目标方法的返回值 = success

目录结构和其他代码与上面类似
代码部分

切入方法

@Aspect
@Component
public class MyAspect {// 前置通知@Before(value = "pointCut()")public void myBefore(JoinPoint jp){System.out.println("前置通知，执行.....");}// 后置通知@AfterReturning(value = "pointCut()",returning = "obj")public void myAfterReturning(Object obj){//参数的名称与注解中returning的值必须一致System.out.println("后置通知，执行.....");}// 环绕通知@Around(value = "pointCut()")public Object myAround(ProceedingJoinPoint pjp) throws Throwable {System.out.println("环绕通知：前置方法........");Object obj = pjp.proceed(pjp.getArgs());System.out.println("环绕通知：后置方法........");return obj;}// 最终通知@After(value = "pointCut()")public void myAfter(){System.out.println("最终通知，执行..........");}// 切入点表达式起别名@Pointcut(value = "execution(* com.springaspects.s5.SomeServiceImpl.*(..))")public void pointCut(){}
}

测试方法

    @Testpublic void test05(){ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContextS05.xml");SomeService someService = (SomeService) ac.getBean("someServiceImpl");String s = someService.doSome("all", 17);System.out.println("测试方法：目标方法的返回值 = " + s);}

Spring集成Mybatis

1. 创建项目

1.1 配置pom.xml

依赖

<dependency><!--单元测试--><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency><!--spring Aop 切面 aspectj依赖--><dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>5.2.5.RELEASE</version></dependency><!--spring核心ioc--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.5.RELEASE</version></dependency><!--做spring事务用到的--><dependency><groupId>org.springframework</groupId><artifactId>spring-tx</artifactId><version>5.2.5.RELEASE</version></dependency><!-- spring 与jdbc的连接--><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.2.5.RELEASE</version></dependency><!--mybatis依赖--><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.6</version></dependency><!--mybatis和spring集成的依赖--><dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>1.3.1</version></dependency><!--mysql驱动--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.32</version></dependency><!--阿里公司的数据库连接池--><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.12</version></dependency>

build

<!--目的是把src/main/java目录中的xml文件包含到输出结果中。输出到classes目录中--><resources><resource><directory>src/main/java</directory><!--所在的目录--><includes><!--包括目录下的.properties,.xml 文件都会扫描到--><include>**/*.properties</include><include>**/*.xml</include></includes><filtering>false</filtering></resource><resource><directory>src/main/resources</directory><!--所在的目录--><includes><!--包括目录下的.properties,.xml 文件都会扫描到--><include>**/*.properties</include><include>**/*.xml</include></includes><filtering>false</filtering></resource></resources>

1.2 Mybatis全局配置

SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration><!--设置日志输出语句,在控制台显示相应操作的sql语名--><settings><setting name="logImpl" value="STDOUT_LOGGING"/></settings>
</configuration>

1.3 Spring接管MyBatis的配置文件

数据库配置文件
jdbc.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=root

applicationContext_Mapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<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/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--    读取属性配置文件--><context:property-placeholder location="jdbc.properties"></context:property-placeholder>
<!--    创建数据源--><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="${jdbc.driverClassName}"></property><property name="url" value="${jdbc.url}"></property><property name="username" value="${jdbc.username}"></property><property name="password" value="${jdbc.password}"></property></bean>
<!--   配置SqlSessionFactoryBean类--><bean class="org.mybatis.spring.SqlSessionFactoryBean">
<!--       配置数据源--><property name="dataSource" ref="dataSource"></property>
<!--        配置MyBatis的核心配置文件--><property name="configLocation" value="SqlMapConfig.xml"></property>
<!--        注册实体类的别名--><property name="typeAliasesPackage" value="实体类所在包全限定包名"></property></bean>
<!--    注册mapper.xml文件--><bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"><property name="basePackage" value="mapper.xml所在包的完全限定包名"></property></bean>
</beans>

1.4 MyBatis的配置文件与Spring接管后的配置文件对比

在这里插入图片描述

1.5 Sping配置

applicationContext_Service.xml

<?xml version="1.0" encoding="UTF-8"?>
<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/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--      包扫描--><context:component-scan base-package="完全限定包名"></context:component-scan>
</beans>

1.6 Mybatis：mapper.xml

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="mapper接口文件的完全限定名称"></mapper>

Spring概念性的东西

两大块核心：IOC和AOP

IOC（控制反转）

概念

IoC（控制反转）：
- 是一种设计模式，目的是将对象的创建和管理从应用程序代码中分离出来，交给外部容器来处理，以符合OCP（开放封闭原则）和DIP（依赖倒置原则）。
- 在 Spring 框架中，IoC 容器负责管理对象（即 Bean）的生命周期和配置。
依赖注入（DI）：
- 是实现 IoC 的具体方式之一。
- 通过 DI，Spring 容器将对象的依赖关系注入到对象中，而不是由对象自己创建或查找这些依赖。
- 这种方式使得对象之间的依赖关系更加清晰和灵活，降低了耦合度。
Spring 框架：
- 实现了 IoC 容器，管理应用程序中的 Bean。
- 使用依赖注入（DI）作为实现 IoC 的主要手段。

具体关系

Spring 框架实现了 IoC：
- Spring 提供了一个 IoC 容器，如 BeanFactory 和 ApplicationContext，用于管理 Bean 的生命周期和配置。
依赖注入（DI）是 Spring 实现 IoC 的方式：
- Spring 通过 DI 将 Bean 的依赖关系注入到 Bean 中，而不是由 Bean 自己创建或查找这些依赖。
- 常见的注入方式包括构造器注入、设值注入和接口注入。
Bean 是被管理的对象：
- Bean 是 Spring 容器管理的对象，其定义和配置信息存储在配置元数据中（如 XML 文件、注解或 Java 配置类）。
- Spring 容器根据这些配置信息创建和管理 Bean 的生命周期，并通过 DI 注入依赖关系。
总结
- Spring 框架实现了 IoC，通过依赖注入（DI）来管理对象（即 Bean）的依赖关系。
- IoC 是一种设计模式，DI 是实现 IoC 的具体方式。