Spring学习路线---组成、IOC详解、第一个Spring程序、IOC创建对象的方式（无参、有参）、bean的配置和别名、依赖注入详解、自动装配、注解开发、代理模式、AOP详解、声明式事务

本文主要是介绍Spring学习路线---组成、IOC详解、第一个Spring程序、IOC创建对象的方式（无参、有参）、bean的配置和别名、依赖注入详解、自动装配、注解开发、代理模式、AOP详解、声明式事务，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1. Spring

1.1 简介

• 2002，首次推出了Spring框架的雏形：interface21

• Spring框架一interface21为基础不断丰富内涵，终于在2004年3月24日，发布了1.0版本。

• Rod Johnson,Spring Framework创始人，著名作者是悉尼大学的博士，可是他的专业是音乐学，而不是计算机。

• Spring的理念：使现有的技术更容易使用，本身是一个大杂烩。支持很多应用。整合了现有的技术框架！

• SSH:Struct2+Spring+Hibernate

• SSM:SpringMVC+Spring+MyBatis

• Spring官网：Spring官网

• 官方下载地址：官方下载地址

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.2.8.RELEASE</version>
</dependency>
<dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.2.8.RELEASE</version>
</dependency>

1.2 优点

• Spring是一个开源的、免费的框架（容器）。
• Spring是一个轻量级的、非入侵式的框架。
  • 轻量级，代码量很少
  • 非入侵，导入之后不会对原先代码产生影响，反而会有利于编写代码。
  • 控制反转(IOC)、面向切面编程（AOP）。
  • 支持事务的处理，对框架整合的支持。
    总结：Spring就是一个轻量级的控制反转（IOC）、面向切面编程（AOP）的框架。

1.3 组成

• Spring框架的七大功能模块
  

1.4 扩展

• Spring Boot:
  • 一个快速开发的脚手架。
  • 基于Spring Boot可以快速开发单个微服务。
  • 约定大于配置。
    -Spring Cloud
  • 基于SpringBoot实现。

现在大多数公司使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring和SpringMVC!

弊端：发展了太久之后，违背了原来的理念！配置十分繁琐，人称“配置地狱！”

---

2.IOC理论推导

2.1 原来实现一个业务的流程：

1. UserDao接口。

2. UserDaoImpl实现类

3. UserService 业务接口

4. UserServiceImpl 业务实现类

在原先的业务中，用户的需求可能会影响我们的代码，我们需要根据用户的需求去修改源代码！如果程序代码量十分大，修改成本就会十分昂贵。
我们使用一个set接口进行实现：

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

• 在没有用setUserDao代码前，程序是主动创建对象，控制权在程序员中。
• 使用set注入之后，程序不再具有主动性，而是变成了被动的接受对象。

这种思想从本质上解决了问题，不用再去管理对象的创建，系统耦合性大大降低，可以更加专注的在业务的实现上。这是IOC的原型。

---

3 HelloSpring

编写一个简单的实例，来使用Spring

3.1 实体类—Hello

package com.swrici.pojo;public class Hello {private String str;public String getStr() {return str;}public void setStr(String str) {this.str = str;}@Overridepublic String toString() {return "Hello{" +"str='" + str + '\'' +'}';}
}

3.2 Application.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"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd">
<!--    使用Spring来创建对象，在Spring中都成为Bean--><!--bean中 id 相当于是生成的对象的标识class是要生成的对应的类bean中的标签property 是设置一个对象里的属性和值的映射--><bean id="hello1" class="com.swrici.pojo.Hello"><property name="str" value="Spring" /></bean>
</beans>

3.3 测试

package com.swrici;import com.swrici.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class MyTest {public static void main(String[] args) {//获取Spring的上下文对象ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");//我们的对象现在都在Spring管理了，我们要使用，直接去Spring中取出来Hello hello =(Hello)  context.getBean("hello1");System.out.println(hello.toString());}
}

3.4 小结

• IOC（控制反转）本质

  • IoC是一种设计思想，DI(依赖注入)是实现IoC的一种方式。

  • 原：对象的创建由程序自己控制。

  • 现：控制反转后，对象的创建转移给了第三方。

  • 采用XML方式配置Bean的时候，Bean的定义信息和实现是分离的，采用注解的方式可以把两者合为一体，Bean的定义信息直接由注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述(XML或注解)的方式将对象的生成交给第三方去生成或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入。

ps: bean标签中的name对应着pojo类中的属性，而且这个pojo类中这个属性必须要有set方法。

何为控制反转？

• 控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的。
• 反转：程序从原来创建对象，到由Spring创建对象而程序只接收对象。
• 依赖注入：利用Set方法来进行注入。
• IOC是一种编程思想，由主动的编程变成被动的接收。
• 对象由Spring来创建，管理和装配。

---

4 IOC创建对象的方式

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

4.2. 如果要使用有参构造创建对象。（3种方法）

1. 下标赋值

<!-- 下标赋值，index起始值为0 -->
<bean id="UserBean" class="com.swrici.pojo.User"><constructor-arg index="0" value="HelloSpring,Swrici!"/>
</bean>

2. 类型赋值

<!-- 参数类型赋值,对象要写完整包路径，基本数据类型直接写 -->
<bean id="UserBean" class="com.swrici.pojo.User"><constructor-arg type="java.lang.String" value="HelloSpringType,Swrici!"/>
</bean>

存在弊端：如果两个参数都是String类型就会出现问题，一个值对应多个参数。（不建议使用）

3. 参数名赋值

<!-- 参数名赋值 -->
<bean id="UserBean" class="com.swrici.pojo.User"><constructor-arg name="name" value="直接参数名"/>
</bean>

4.3 小结

• 在配置文件初始化的时候对象就已经初始化了
• 一个XML文件中不能出现多个id相同的bean.
• 在创建对象是，XML中所有的bean都会被创建！
• 在容器中一个类只会创建一个对象。

---

5 Spring配置

5.1 别名

<!--别名，原来的名字和别名都可以同时使用-->
<alias name="UserBean" alias="user"/>

5.2 bean的配置

<!--bean标签中的属性：id:bean的唯一标识符，也就是相当于我们学的对象名class:bean 对象所对应的全限定名（包名+类名）name:也是别名，而且name可以同时取多个别名,用空格，逗号都能做分割
-->
<bean id="UserBean" class="com.swrici.pojo.UserT" name="userTA,u 要;u4"><property name="name" value="userT"/>
</bean>

5.3 import

多用于团队开发，可以将多个配置文件导入合并为一个总的配置文件，其中重复的bean会被合并。

6 依赖注入（DI）

6.1 构造器注入（详见4.2）

之前已经讲过了

6.2 Set方式注入【重要】

• 依赖注入：Set注入
  - 依赖：bean对象的创建都依赖容器。
  - 注入：beam对象的属性都由容器来注入。

环境搭建：

1. 复杂类型

public class Address {private String address;public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}
}

2. 真实测试对象

public class Student {private String name;private Address address;private String[] book;private List<String> hobbys;private Map<String,String> card;private Set<String> game;private Properties info;private String wife;
}

3. 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"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd"><!--第一种注入，普通方法注入，value--><bean id="student" class="com.swrici.pojo.Student"><property name="name" value="swrici"/></bean>
</beans>

4. 测试

public class MyTest {public static void main(String[] args) {ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");Student student = (Student) applicationContext.getBean("student");System.out.println(student.getName());}
}

5. 完善set的注入信息

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="student" class="com.swrici.pojo.Student"><!--第一种注入，普通方法注入，value--><property name="name" value="swrici"/><!--第二种注入，bean注入，ref--><property name="address" ref="address"/><!--第三种注入，数组注入，--><property name="book"><array><value>《红楼梦》</value><value>《水浒传》</value><value>《三国演义》</value><value>《西游记》</value></array></property><!--第四种注入，list注入，--><property name="hobbys" ><list><value>跑步</value><value>吃美食</value><value>旅游</value></list></property><!--第五种注入，Map注入，--><property name="card" ><map><entry key="teacher" value="happy"/><entry key="Id" value="1234567897895461"/><entry key="gogo" value="45678912354789"/></map></property><!--第六种注入，Set注入，--><property name="game" ><set><value>LOL</value><value>WOW</value><value>COC</value></set></property><!--第七种注入，null注入，--><property name="wife" ><null/></property><!--第八种注入，Properties注入--><property name="info"><props><prop key="driver">185954325</prop><prop key="性别">男</prop><prop key="姓名">小明</prop></props></property></bean><bean id="address" class="com.swrici.pojo.Address"><property name="address" value="图书馆"/></bean>
</beans>

6.3 拓展方式注入

我们可以同C命名空间和P命名空间进行注入。

<?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:p="http://www.springframework.org/schema/p"xmlns:c="http://www.springframework.org/schema/c"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd"><!--p命名 空间注入--><bean id="user" class="com.swrici.pojo.User" p:name="学民" p:age="22"/><!--c命名空间注入,需要要有有参构造函数--><bean id="userC" class="com.swrici.pojo.User" c:name="Cnamespace" c:age="18"/>
</beans>
</beans>

• 测试

@Test
public void pTest(){ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");User user =(User) context.getBean("user");System.out.println(user.toString());
}@Test
public void cTest(){ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");User userC = context.getBean("userC", User.class);System.out.println(userC.toString());}

注意：
p命名空间和c命名空间不能直接使用，需要导入xml约束。

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

6.4 bean的作用域

1. 单例模式singleton(Spring默认机制)
   工厂中用同一个id创建的对象引用地址是相同的。

<bean id="user" class="com.swrici.pojo.User" p:name="学民" p:age="22" scope="singleton"/>

2. 原先模式prototype
   每次使用都会获得一个新的对象。不会重复。

<bean id="user" class="com.swrici.pojo.User" p:name="学民" p:age="22" scope="prototype"/>

3. 其他的request、session、application、websocket这些只能在web开发中使用到。

7 bean的自动装配

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

在Spring中有三种装配方式

1. 在xml中显示配置
2. 在java中显示配置
3. 隐式的自动装配bean【重要】

7.1 测试

例子：一个人有两个宠物。

7.2 autowire:byName自动装配

<!--byName:会自动在容器上下文中查找和自己对象set方法后面对应的值（beanid）
-->
<bean id="person" class="com.swrici.pojo.Person" autowire="byName"><property name="name" value="一个无名人" />

7.3 autowire:byType自动装配

<!--byName:会自动在容器上下文中查找，和自己对象set方法后面对应的值（beanid）byType:会自动在容器上下文中查找，和自己对象属性类型一样的bean，同类型两个以上不同id报错。
-->
<bean id="person" class="com.swrici.pojo.Person" autowire="byType"><property name="name" value="一个无名人" /></bean>

小结

• 使用byName时，确保所有bean的id唯一，并且bean的id要和自动注入的属性的set方法名set后的值一致。
• 使用byType时，确保所有bean的class唯一，并且bean的类型名要和自动注入的属性的类型一致。

7.4 使用注解自动装配

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

要实现注解须知：

1. 导入约束.

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

2. 配置注解的支持. <context:annotation-config/>

<context:annotation-config/>

@Autowired
小结

• 可以在属性和set方法上使用。
• 在使用时也可以不需要set方法使用

科普：

• @Nullable注解，使用该注解标记某个字段，意味着允许该字段为空。

private @Nullable String name;

• @Autowired(required = false) 表示这个对象可以是空，否则不允许为空。
• @Qualifer(value=“id”) 在容器中存在多个同类型不同id（@Autowired 的自动装配环境比较复杂，无法通过一个@Autowired 完成）时使用，自动装配的时哪个bean,id是对应Bean的id。

public class Person {//使用了@Autowired(required = false) 表示这个对象可以是空，否则不允许为空@Autowired(required = false)@Qualifier(value = "cat1234")private Cat cat;@Autowired@Qualifier(value = "dog123")private Dog dog;
}

• @Resource两种byName和byType都执行
  在不设置name的情况下，面对复杂的装配会报错，name对应的是bean的id。

public class Person {@Resource(name = "cat2")private Cat cat;@Resourceprivate Dog dog;private String name;public String getName() {return name;}
}

小结：
@Resource 和 @Autowired 的区别：

相同：

• 两者都是用来自动装配的 ，都可以放在属性字段上。

不同：

实现方式不同：

• @Autowired 默认通过byType方式实现。【常用】
• @Resource默认通过byName方式，如果两个都找不到则通过byType实现，如果两个都找不到，则报错。

执行顺序不同：

• @Autowired 默认先通过byType方式实现，
• @Resource默认先通过byName方式。

---

8 使用注解开发

8.1 bean

• 在Spring4之后要是有注解开发，必须有导入AOP的包。
  
• 使用注解要在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/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsd"><!--开启注解支持--><context:annotation-config/>
</beans>

@Component:组件，说明该类被Spring管理了，就是这个类是Spring里的一个bean，默认的beanid是类的小写。

8.2 属性如何注入

@Value

@Component
public class User {public String name ;//相当于 <property name="name" value="劳模森"/>//@Value也可以加在属性上@Value("劳模森") public void setName(String name) {this.name = name;}
}

8.3 衍生的注解

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

• dao ：@Repository,和@Component是一样作用的，把该类放到容器里，但是在dao层我们常用@Repository,
• service：@Service
• controller：@Controller
  四个注解功能是一样的，将某个类注册到Spring中，装配bean。

8.4 自动装配

• Autowired:自动装配通过类型，名字。如果Autowired不能唯一识别对应的bean的话，需要加上Qualifer(value=“XXX”)。- @Nullable注解，使用该注解标记某个字段，意味着允许该字段为空。
• Resource:自动装配通过名字，类型。

8.5 作用域

@Component
@Scope("prototype")
public class User {public String name ;@Value("劳模森") //相当于 <property name="name" value="劳模森"/>public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +'}';}
}

8.6 小结

xml和注解：

• xml比较万能，使用任何场合，维护简单方便。
• 注解：不是自己类用不了，维护相对复杂。

最佳实践：

• xml：用来管理bean。
• 注解：只负责属性的注入。
• 我们在使用的过程只需要注意一个问题，要想让注解生效，就必须要开启注解的支持。

---

9 使用Java的方式配置Spring

我们现在要完全不使用Spring的XML配置，全权交给Java来做。
JavaConfig早期是Spring的一个子项目，在Spring4之后，他成为了一个核心。
实体类User：

package com.swrici.pojo;import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;public class User {private String name;public String getName() {return name;}@Value("Hellolaomo!")public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +'}';}
}

• 配置类MyConfig:

package com.swrici.config;import com.swrici.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;/*这个@Configuration注解也包含着@Component，也被注册到Spring容器中，@Configuration代表这是一个配置类，就和之前看的beans.xml一样
*/
@Configuration
@ComponentScan("com.swrici.pojo")
@Import(MyConfig2.class)
public class MyConfig {/*注册一个bean，相当于之前在xml文件里写的一个bean标签方法的名字就相当于 bean标签的id属性方法的返回值就相当于 bean标签的class属性*/@Beanpublic User getUser(){//return new User();}
}

测试类

/*这个@Configuration注解也包含着@Component，也被注册到Spring容器中，@Configuration代表这是一个配置类，就和之前看的beans.xml一样
*/
@Configuration
@ComponentScan("com.swrici.pojo")
@Import(MyConfig2.class)
public class MyConfig {/*注册一个bean，相当于之前在xml文件里写的一个bean标签方法的名字就相当于 bean标签的id属性方法的返回值就相当于 bean标签的class属性*/@Beanpublic User getUser(){//return new User();}
}

这种纯Java的配置方式，在SpringBoot中随处可见

---

10 代理模式

为什么要学代理模式呢？
因为这就是SpringAOP的底层实现。
代理模式的分类：

• 静态代理
• 动态代理

代理过程类似于下图：

10.1 静态代理

角色分析：

• 抽象角色：一般会使用接口或抽象类来解决
• 真实角色：被代理的角色
• 代理角色：代理真实角色，代理真实角色之后，我们一般会做一些附属操作
• 客户： 访问代理角色的人

代码步骤：

1. 接口

public interface Rent {public void rent();
}

2. 真实角色

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

3. 代理角色

public class Proxy implements Rent{private Host host;public Proxy() {}public Proxy(Host host) {this.host = host;}//中介出租房子public void rent() {host.rent();seeHourse();signAContact();fare();}//看房public void seeHourse(){System.out.println("中介带你取看房");}//收中介费public void  fare(){System.out.println("中介跟你收中介费");}//签租赁合同public void signAContact(){System.out.println("中介跟你签合同");}
}

4. 客户端访问代理角色

public class Client {public static void main(String[] args) {Host host = new Host();Proxy proxy = new Proxy(host);proxy.rent();}
}

代理模式的好处：

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

缺点：

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

10.2 加深理解

10.3 动态代理

• 动态代理和静态代理的角色一样
• 动态代理的代理角色在运行过程中产生，不是直接写好的。
• 动态代理实现分成两大类，基于接口的动态代理，基于类的动态代理。
  • 基于接口：JDK 动态代理
  • 基于类：cglib
  • Java字节码实现：javasist

需要了解两个类：Proxy(代理类),InvocationHandler(调用处理程序)【坑1】

动态代理的好处：

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

---

11 AOP

11.1 什么是AOP

AOP(Aspect Oriented Programming)意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的功能。

AOP是OOP的一种延续，是软件开发的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。

利用AOP可以对业务逻辑的各个部分进行隔离，从而让业务逻辑各部分之间的耦合性降低，提高程序的可重用性，同时提高了开发的效率。

11.2 AOP在Spring中的作用

提高声明式事务，允许用户自定义切面

• 横切关注面：跨越应用程序多个模块的方法和功能。既是，与我们业务逻辑无关的，但是是我们需要关注的部分，就是横切关注点，比如日志，安全，缓存，事务等等；
• 切面（Spect）, 横切关注点被模块化的特殊对象，是一个类。
• 通知（Advice）: 切面必须完成的工作，是类中的一个方法。
• 目标（Target）: 被通知对象。
• 代理（Proxy）: 向目标应用对象通知之后创建的对象。
• 切入点（PointCut）:切面通知 执行的”地点“的定义。
• 连接点（JointPoint）: 与切入点相匹配的执行点。

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

11.3 使用Spring实现AOP

<dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.4</version>
</dependency>

方式一：使用Spring的API接口实现

方式二：自定义类实现AOP【主要是切面定义】

方式三：注解实现AOP

12 整合MyBatis

1. 导包
   Junit
   MySQL
   MyBatis
   Spring
   AOP
   MyBatis-Spring

<dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.46</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.2</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.1.9.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.1.9.RELEASE</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.8.13</version></dependency><!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring --><dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>2.0.5</version></dependency></dependencies>

编写配置文件
测试

12.1 回忆MyBatis

• 编写实体类
• 编写核心配置文件
• 编写接口
• 编写Mapper.xml

遇到问题：

• 静态资源加载问题(pom中)

<build>
<resources><resource><directory>src/main/java</directory><includes><include>**/*.properties</include><include>**/*.xml</include></includes><filtering>false</filtering></resource><resource><directory>src/main/resources</directory><includes><include>**/*.properties</include><include>**/*.xml</include></includes><filtering>false</filtering></resource>
</resources>
</build>

12.2 MyBatis-Spring

1. 编写数据源配置
2. SqlSessionFactory
3. SqlSessionTemplate
4. 给接口加实现类
5. 将自己写的实现类注入到Spring中。
6. 然后测试使用。

---

13 声明式事务

13.1 回顾事务

• 把一组业务当成一个业务来做要么都成功，要么都失败
• 事务在项目开发中，十分重要，涉及到数据的一致性问题，不容马虎。
• 确保完整性和一致性。

事务的ACID原则：

• 原子性：
• 一致性：
• 隔离性：
• 永久性：

13.2 Spring中的事务

• 声明式事务：AOP的一个应用。
• 编程式事务：需要在代码中进行事务的管理。

思考：
为什么需要事务？

• 如果不配置事务，可能会存在数据提交不一致的情况。
• 如果我们不在Spring中配置声明式事务，我们就需要在代码中手动配置事务。
• 事务在项目开发中十分重要，涉及到数据的一致性和完整性的问题，不容马虎！

这篇关于Spring学习路线---组成、IOC详解、第一个Spring程序、IOC创建对象的方式（无参、有参）、bean的配置和别名、依赖注入详解、自动装配、注解开发、代理模式、AOP详解、声明式事务的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---