Spring介绍

1.1 简介
1.2 优点
1.3 组成
1.4 扩展
2. IOC
3. spring注入
- 3.1 简介
- 3.2 注入方式
4. bean作用域
5. 自动装配
- 5.1 使用xml自动装配
- 5.2 使用注解自动配置
6. 使用注解开发
7 使用纯java进行配置
8. AOP
9. MyBatis
- 9.1 mybatis原生开发
- 9.2 使用spring整合mybatis开发
10. spring事务
- 10.1 使用aop织入事务

1.1 简介

Spring : 春天 —->给软件行业带来了春天

2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。

2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。

很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。

Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术

官网 : http://spring.io/

官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/

GitHub : https://github.com/spring-projects

1.2 优点

spring 是一个开源的免费的框架（容器）
spring 是轻量级的、非侵入式的框架
控制反转（IOC）、面向切面（AOP）编程
1. Inversion of Control
2. Aspect-Oriented Programming
支持事务处理，对框架整合的支持

总结：spring就是一个轻量级的控制反转和面向切面编程的框架

1.3 组成

Spring介绍 - 图1

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式 .

Spring介绍 - 图2

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中。
Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

1.4 扩展

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中。
Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

Spring介绍 - 图3

Spring Boot

一个快速开发的手脚架
基于SpringBoot可以快速的开发单个微服务
约定大于配置

Spring Cloud

Spring Cloud是基于spring boot 实现的

2. IOC

2.1 引入IOC

新建一个空白的maven项目，使用这个项目来说明IOC原理

先按照原来的方式写一段代码

1、先写一个UserDao接口

public interface UserDao {
   public void getUser();
}

2、再去写Dao的实现类

public class UserDaoImpl implements UserDao {
   @Override
   public void getUser() {
       System.out.println("获取用户数据");
  }
}

3、然后去写UserService的接口

public interface UserService {
   public void getUser();
}

4、最后写Service的实现类

public class UserServiceImpl implements UserService {
   private UserDao userDao = new UserDaoImpl();
   @Override
   public void getUser() {
       userDao.getUser();
  }
}

5、测试一下

@Test
public void test(){
   UserService service = new UserServiceImpl();
   service.getUser();
}

这是我们原来的方式 , 开始大家也都是这么去写的对吧 . 那我们现在修改一下 .

把Userdao的实现类增加一个 .

public class UserDaoMySqlImpl implements UserDao {
   @Override
   public void getUser() {
       System.out.println("MySql获取用户数据");
  }
}

紧接着我们要去使用MySql的话 , 我们就需要去service实现类里面修改对应的实现

public class UserServiceImpl implements UserService {
   private UserDao userDao = new UserDaoMySqlImpl();
   @Override
   public void getUser() {
       userDao.getUser();
  }
}

在假设, 我们再增加一个Userdao的实现类 .

public class UserDaoOracleImpl implements UserDao {
   @Override
   public void getUser() {
       System.out.println("Oracle获取用户数据");
  }
}

那么我们要使用Oracle , 又需要去service实现类里面修改对应的实现 . 假设我们的这种需求非常大 , 这种方式就根本不适用了, 甚至反人类对吧 , 每次变动 , 都需要修改大量代码 . 这种设计的耦合性太高了, 牵一发而动全身 .

那我们如何去解决呢 ?

我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用set , 我们去代码里修改下 .

public class UserServiceImpl implements UserService {
   private UserDao userDao;
// 利用set实现
   public void setUserDao(UserDao userDao) {
       this.userDao = userDao;
  }
   @Override
   public void getUser() {
       userDao.getUser();
  }
}

现在去我们的测试类里 , 进行测试 ;

@Test
public void test(){
   UserServiceImpl service = new UserServiceImpl();
   service.setUserDao( new UserDaoMySqlImpl() );
   service.getUser();
   //那我们现在又想用Oracle去实现呢
   service.setUserDao( new UserDaoOracleImpl() );
   service.getUser();
}

大家发现了区别没有 ? 以前所有东西都是由程序去进行控制创建 , 而现在是由我们自行控制创建对象 , 把主动权交给了调用者 . 程序不用去管怎么创建,怎么实现了 . 它只负责提供一个接口 .

这种思想 , 从本质上解决了问题 , 我们程序员不再去管理对象的创建了 , 更多的去关注业务的实现 . 耦合性大大降低 . 这也就是IOC的原型 !

NOTE:

之前，是程序主动创建对象，控制权在程序手里
使用set注入之后，程序不再具备主动性，而是变成了被动的接受对象，用户获取了程序的主动性

2.2 IOC本质

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方 ，反转的意思就是对象的创建主动权反转了。

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

Your application classes are combined with configuration metadata so that, after the ApplicationContext is created and initialized, you have a fully configured and executable system or application.

Spring介绍 - 图4

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

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

代码测试

hello.java

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

beans.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/beans
     https://www.springframework.org/schema/beans/spring-beans.xsd">
 <bean id="hello" class="Hello">
     <property name="str" value="spring"/>
 </bean>
</beans>

The id attribute is a string that identifies the individual bean definition.
The class attribute defines the type of the bean and uses the fully qualified classname.

测试代码

@Test
public void helloTest(){
 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
 Hello hello = (Hello) applicationContext.getBean("hello");
 System.out.println(hello.toString());
}

思考

Hello 对象是谁创建的 ? 【hello 对象是由Spring创建的
Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的

这个过程就叫控制反转 :

控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
反转 : 程序本身不创建对象 , 而变成被动的接收对象 .

依赖注入 : 就是利用set方法来进行注入的.

IOC是一种编程思想，由主动的编程变成被动的接收

2.3 IOC创建对象的方式

默认通过无参构造创建对象
创建对象的时间：在拿到容器的时候所有.xml文件中配置的对象就创建完成了，且通过同一个id创建的对象是一样的
```
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
```

通过有参构造的方式创造对象的三种方式

通过参数索引

<bean class="User" id="user">
  <constructor-arg index="0" value="spring"/>
</bean>

通过参数类型{不推荐}

<bean class="User" id="user">
<constructor-arg type="java.lang.String" value="spring"/>
</bean>

通过参数的名称{推荐}

<bean class="User" id="user">
  <constructor-arg name="name" value="spring"/>
</bean>

2.4 spring配置

2.4.1 alias

alias : 为bean设置别名，id可以传入userNew取对象

<alias name="userT" alias="userNew"/>

2.4.2 bean

<!--bean就是java对象,由Spring创建和管理-->

<!--
   id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
   如果配置id,又配置了name,那么name是别名
   name可以设置多个别名,可以用逗号,分号,空格隔开
   如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;

class是bean的全限定名=包名+类名
-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
   <property name="name" value="Spring"/>
</bean>

2.4.3 import

团队的合作通过import来实现 .

<import resource="{path}/beans.xml"/>
<import resource="{path}/beans1.xml"/>
<import resource="{path}/beans2.xml"/>

3. spring注入

3.1 简介

依赖注入（DI: dependency injection）：

依赖：bean对象的创建依赖于容器
注入：指bean对所依赖的资源，由容器设置和装配

3.2 注入方式

3.2.1 构造器注入

<bean class="User" id="user">
        <constructor-arg name="name" value="spring"/>
</bean>

3.2.2 set注入{重点}

要求被注入的属性 , 必须有set方法

环境搭建

pojo类

@Data
public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbies;
    private Map<String, String> card;
    private Set<String> games;
    private String wife;
    private Properties info;
}
@Data
public class Address {
    private String address;
}

beans.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/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="stu" class="com.iandf.pojo.Student">
        <!--value注入-->
        <property name="name" value="黄鹤"/>
        <!--bean注入-->
        <property name="address" ref="address"/>
        <!--数组-->
        <property name="books">
            <array>
                <value>红楼梦</value>
                <value>水浒传</value>
                <value>三国演义</value>
            </array>
        </property>
        <!--list-->
        <property name="hobbies">
            <list>
                <value>敲代码</value>
                <value>看电影</value>
            </list>
        </property>
        <!--map-->
        <property name="card">
            <map>
                <entry key="学号" value="123456"/>
            </map>
        </property>
        <!--set-->
        <property name="games">
            <set>
                <value>lol</value>
                <value>王者</value>
            </set>
        </property>
        <!--null-->
        <property name="wife">
            <null/>
        </property>
        <!--properties-->
        <property name="info">
            <props>
                <prop key="银行卡">123414564</prop>
            </props>
        </property>
    </bean>
    <bean id="address" class="com.iandf.pojo.Address">
        <property name="address" value="湖南"/>
    </bean>
</beans>

测试类

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student stu = (Student) context.getBean("stu");
System.out.println(stu.toString());

结果

/*Student(name=黄鹤
        , address=Address(address=湖南)
        , books=[红楼梦, 水浒传, 三国演义]
        , hobbies=[敲代码, 看电影]
        , card={学号=123456}
        , games=[lol, 王者]
        , wife=null
        , info={银行卡=123414564})*/

3.2.3 扩展注入

Spring supports extensible configuration formats with namespaces, which are based on an XML Schema definition

xml shortcut with the p-namespace 相当于property标签

导入命名空间

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

使用

<bean id="user" class="com.iandf.pojo.User" p:id="123" p:name="黄鹤"/>

xml shortcut with c-namespace 相当于constructor-arg标签

导入命名空间

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

使用

<bean id="user2" class="com.iandf.pojo.User" c:id="456" c:name="利诱">

4. bean作用域

Spring介绍 - 图5

单例模式（默认的）：spring容器为每一个bean分配一个对象
原型模式：每一次从spring容器中获取到的对象都是新的
```
<bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>
```
request、session、…都是在web应用中使用的

5. 自动装配

自动装配说明

自动装配是使用spring满足bean依赖的一种方法
spring会在应用上下文中为某个bean寻找其依赖的bean。

Spring中bean有三种装配机制，分别是：

在xml中显式配置；
在java中显式配置；
隐式的bean发现机制和自动装配。

这里我们主要讲第三种：自动化的装配bean。

Spring的自动装配需要从两个角度来实现，或者说是两个操作：

组件扫描(component scanning)：spring会自动发现应用上下文中所创建的bean；
自动装配(autowiring)：spring自动满足bean之间的依赖，也就是我们说的IoC/DI；

组件扫描和自动装配组合发挥巨大威力，使得显示的配置降低到最少。

推荐不使用自动装配xml配置 , 而使用注解 .

5.1 使用xml自动装配

测试环境搭建

1、新建一个项目

2、新建两个实体类，Cat Dog 都有一个叫的方法

public class Cat {
   public void shout() {
       System.out.println("miao~");
  }
}
public class Dog {
   public void shout() {
       System.out.println("wang~");
  }
}

3、新建一个用户类 User

public class User {
   private Cat cat;
   private Dog dog;
   private String str;
}

4、编写Spring配置文件

<?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/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

   <bean id="dog" class="com.kuang.pojo.Dog"/>
   <bean id="cat" class="com.kuang.pojo.Cat"/>

   <bean id="user" class="com.kuang.pojo.User">
       <property name="cat" ref="cat"/>
       <property name="dog" ref="dog"/>
       <property name="str" value="qinjiang"/>
   </bean>
</beans>

5、测试

public class MyTest {
   @Test
   public void testMethodAutowire() {
       ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
       User user = (User) context.getBean("user");
       user.getCat().shout();
       user.getDog().shout();
  }
}

结果正常输出，环境OK

byName

autowire byName (按名称自动装配)

由于在手动配置xml过程中，常常发生字母缺漏和大小写等错误，而无法对其进行检查，使得开发效率降低。

采用自动装配将避免这些错误，并且使配置简单化。

测试：

1、修改bean配置，增加一个属性 autowire=”byName”

<bean id="user" class="com.kuang.pojo.User" autowire="byName">
   <property name="str" value="qinjiang"/>
</bean>

2、再次测试，结果依旧成功输出！

3、我们将 cat 的bean id修改为 catXXX

4、再次测试，执行时报空指针java.lang.NullPointerException。因为按byName规则找不对应set方法，真正的setCat就没执行，对象就没有初始化，所以调用时就会报空指针错误。

小结：

当一个bean节点带有 autowire byName的属性时。

将查找其类中所有的set方法名，例如setCat，获得将set去掉并且首字母小写的字符串，即cat。
去spring容器中寻找是否有此字符串名称id的对象。
如果有，就取出注入；如果没有，就报空指针异常。

byType

autowire byType (按类型自动装配)

使用autowire byType首先需要保证：同一类型的对象，在spring容器中唯一。如果不唯一，会报不唯一的异常。

NoUniqueBeanDefinitionException

测试：

1、将user的bean配置修改一下： autowire=”byType”

2、测试，正常输出

3、在注册一个cat 的bean对象！

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat" class="com.kuang.pojo.Cat"/>
<bean id="cat2" class="com.kuang.pojo.Cat"/>

<bean id="user" class="com.kuang.pojo.User" autowire="byType">
   <property name="str" value="qinjiang"/>
</bean>

4、测试，报错：NoUniqueBeanDefinitionException

5、删掉cat2，将cat的bean名称改掉！测试！因为是按类型装配，所以并不会报异常，也不影响最后的结果。甚至将id属性去掉，也不影响结果。

这就是按照类型自动装配！

5.2 使用注解自动配置

5.2.1 配置环境

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

</beans>

5.2.2 @autowired

@autowired默认是byType，byType找不到再使用byName

如果出现多个bean且byName找不到的情况下可以使用@Qualifier(“xxx”) xxx为bean的id

    @Autowired
    @Qualifier("cat1")
    private Cat cat;
    @Autowired
    @Qualifier("dog1")
    private Dog dog;
    <bean id="dog2" class="Dog"/>
    <bean id="dog1" class="Dog"/>
    <bean id="cat1" class="Cat"/>
    <bean id="cat2" class="Cat"/>
    <bean id="person" class="Person">
        <property name="name" value="huang"/>
    </bean>

5.2.3 @Resource

@Resource默认是byName,byType找不到再byType

byName和byType都找不到的情况下使用 @Resource(name = “xxx”) xxx为bean的id

    @Resource(name = "cat1")
    private Cat cat;
    @Resource
    private Dog dog;
    <bean id="dog" class="Dog"/>
    <bean id="cat1" class="Cat"/>
    <bean id="cat2" class="Cat"/>
    <bean id="person" class="Person">
        <property name="name" value="huang"/>
    </bean>

5.2.4 小结

@Autowired与@Resource异同：

1、@Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。

2、@Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用

3、@Resource（属于J2EE复返），默认按照名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

它们的作用相同都是用注解方式注入对象，但执行顺序不同。@Autowired先byType，@Resource先byName。

6. 使用注解开发

我们之前都是使用 bean 的标签进行bean注入，但是实际开发中，我们一般都会使用注解！

配置环境

在配置文件当中，还得要引入一个context约束，配置扫描哪些包的注解

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>
    <context:component-scan base-package="com.iandf.pojo"/>

</beans>

6.1 使用注解实现bean配置和属性的注入

@Component(value = "user")//默认就是user
public class User {
    @Value("iandf")//优先使用
    private String name = "aaa";
}

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
@Value("iandf")
// 相当于配置文件中 <property name="name" value="iandf"/>,也可以写在set方法上

6.2 Component的衍生注解

为了更好的进行分层，Spring可以使用其它三个注解，功能一样，目前使用哪一个功能都一样。

@Controller：web层
@Service：service层
@Repository：dao层

写上这些注解，就相当于将这个类交给Spring管理装配了！

6.3 自动配置注解看第五章节

6.4 作用域

@scope

singleton：默认的，Spring会采用单例模式创建这个对象。关闭工厂，所有的对象都会销毁。
prototype：多例模式。关闭工厂，所有的对象不会销毁。内部的垃圾回收机制会回收

@Component(value = "user")
@Scope("prototype")
public class User {
    @Value("iandf")//优先使用
    private String name = "aaa";   
}

6.5 小结

XML与注解比较

XML可以适用任何场景，结构清晰，维护方便
注解不是自己提供的类使用不了，开发简单方便

xml与注解整合开发 ：推荐最佳实践

xml管理Bean
注解完成属性注入
使用过程中，可以不用扫描，扫描是为了类上的注解

<context:annotation-config/>

作用：

进行注解驱动注册，从而使注解生效
用于激活那些已经在spring容器里注册过的bean上面的注解，也就是显示的向Spring注册
如果不扫描包，就需要手动配置bean
如果不加注解驱动，则注入的值为null

7 使用纯java进行配置

JavaConfig 原来是 Spring 的一个子项目，它通过 Java 类的方式提供 Bean 的定义信息，在 Spring4 的版本， JavaConfig 已正式成为 Spring4 的核心功能。

测试

编写config类

@Configuration//代表这是一个配置类,相当于beans.xml，同时将BeansConfig交给spring管理
public class BeansConfig {
 @Bean//id是方法名，class是返回值类型
 public User getUser(){
     return new User();
 }
}

编写一个实体类,使用component标注

@Component
public class User {
 private String name = "iandf";
}

测试使用纯注解方式需要通过AnnotationConfigApplicationContext类拿到容器

@Test
public void javaConfigTest(){
 ApplicationContext context = new AnnotationConfigApplicationContext("com.iandf.config");
 BeansConfig beansConfig = context.getBean("beansConfig", BeansConfig.class);
 User user = beansConfig.getUser();
 System.out.println(user.toString());
}
@Test
public void javaConfigTest2() {
 ApplicationContext context = new AnnotationConfigApplicationContext("com.iandf.config");
 User user = context.getBean("getUser", User.class);
 System.out.println(user.toString());
}

也可以使用@Import(XxxConfig.class) 导入其他配置类相当于inculde 标签

关于这种Java类的配置方式，我们在之后的SpringBoot 和 SpringCloud中还会大量看到，我们需要知道这些注解的作用即可！

8. AOP

8.1 什么是aop

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

Spring介绍 - 图6

8.2 aop在spring中的作用

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

以下名词需要了解下：

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

Spring介绍 - 图7

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

before advice, 在 join point 前被执行的 advice. 虽然 before advice 是在 join point 前被执行, 但是它并不能够阻止 join point 的执行, 除非发生了异常(即我们在 before advice 代码中, 不能人为地决定是否继续执行 join point 中的代码)
after return advice, 在一个 join point 正常返回后执行的 advice
after throwing advice, 当一个 join point 抛出异常后执行的 advice
after(final) advice, 无论一个 join point 是正常退出还是发生了异常, 都会被执行的 advice.
around advice, 在 join point 前和 joint point 退出后都执行的 advice. 这个是最常用的 advice.

即 Aop 在不改变原有代码的情况下 , 去增加新的功能 .

8.3 使用spring实现aop

需求：使UserServiceImpl 在不改变源码的情况下，使它原本的增删改查实现前置日志和后置日志的功能

8.3.1 使用spring api 实现

搭建环境

public interface IUserService {
    void add();
    void delete();
    void update();
    void select();
}
public class UserServiceImpl implements IUserService{
    public void add() {
        System.out.println("添加一个用户");
    }

    public void delete() {
        System.out.println("删除一个用户");
    }

    public void update() {
        System.out.println("修改一个用户");
    }

    public void select() {
        System.out.println("查询一个用户");
    }
}

Log类

public class BeforeLog implements MethodBeforeAdvice {
    public void before(Method method, Object[] args, Object target) {
        System.out.println((target != null ? target.getClass().getName() : null) +"执行了"+method.getName()+"方法");
    }
}
public class AfterLog implements AfterReturningAdvice {
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println((target != null ? target.getClass().getName() : null) +"执行完了"+method.getName()+"返回值为: "+returnValue);
    }
}

配置文件

<?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: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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class="com.iandf.service.UserServiceImpl"/>
    <bean id="afterLog" class="com.iandf.log.AfterLog"/>
    <bean id="beforeLog" class="com.iandf.log.BeforeLog"/>
    <aop:config>
         <!--切入点 expression:表达式匹配要执行的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.iandf.service.UserServiceImpl.*(..))"/>
        <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

定义切点：

expression="execution(* com.iandf.service.UserServiceImpl.*(..))

对这个表达式分析：

- 表示返回值的方法
com.iandf.service.UserServiceImpl.* 表示UserServiceImpl类中的任意方法
(..)表示任意参数

测试代码

@Test
public void LogTest(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    //获取代理对象，注意代理对象是其接口的实现类
    IUserService userService = context.getBean("userService", IUserService.class);
    userService.add();
}

测试结果

Spring介绍 - 图8

Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来 . 实现公共业务的重复利用 . 领域业务更纯粹 , 程序猿专注领域业务 , 其本质还是动态代理 .

8.3.2 使用自定义类实现aop

步骤：

自己自动一个Log类
在配置文件中配置切入面，切入点，通知

log类

public class LogAopDiy {

    public void before(){
        System.out.println("方法执行前");
    }

    public void after(){
        System.out.println("方法执行后");
    }
}

配置文件

<bean id="diy" class="com.iandf.diy.LogAopDiy"/>
<aop:config>
    <aop:aspect ref="diy">
        <!--切入点-->
        <aop:pointcut id="pointcut" expression="execution(* com.iandf.service.UserServiceImpl.*(..))"/>
        <!--通知：要执行的方法-->
        <aop:after method="after" pointcut-ref="pointcut"/>
        <aop:before method="before" pointcut-ref="pointcut"/>
    </aop:aspect>
</aop:config>

测试结果

Spring介绍 - 图9

8.3.3 使用注解实现aop

步骤：

自定义一个带有注解的Log类
在配置文件中配置bean和开启注解

AnnotationAop

@Aspect//把该类定义成一个切面
public class AnnotationAop {
    @Before(value = "execution(* com.iandf.service.UserServiceImpl.*(..))")//配置切入点
    public void before(){
        System.out.println("方法执行前");
    }

    @After(value = "execution(* com.iandf.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("方法执行后");
    }

    @AfterReturning(value = "execution(* com.iandf.service.UserServiceImpl.*(..))")
    public void afterReturning(){
        System.out.println("方法返回结果");
    }

    @Around(value = "execution(* com.iandf.service.UserServiceImpl.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        //ProceedingJoinPoint joinPoint与切入点匹配的执行点。
        System.out.println("方法环绕前");
        Object proceed = joinPoint.proceed();//执行目标对象调用的方法
        System.out.println("方法环绕后");
        return proceed;
    }
}

配置文件

<bean id="annotationAop" class="com.iandf.annotation_aop.AnnotationAop"/>
<!--支持注解-->
<aop:aspectj-autoproxy proxy-target-class="false"/>

aop:aspectj-autoproxy：说明

通过aop命名空间的声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被隐藏起来了

有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。

9. MyBatis

9.1 mybatis原生开发

步骤：

编写mybatis-config.xml 添加数据源
编写实体类 eg:User
编写接口 eg:UserMapper
编写接口配置文件 eg:UserMapper.xml 写sql语句
在mybatis-config.xml中添加mapper
写测试类

代码案例

User、UserMapper 和 UserMapper.xml

@Data
public class User {
    private int id;
    private String name;
    private String password;
}
public interface UserMapper {
    List<User> getUserList();
}
<?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="com.iandf.dao.UserMapper">
    <select id="getUserList" resultType="user">
        select * from mybatis.user
    </select>
</mapper>

mybatis-config.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>
    <typeAliases>
        <package name="com.iandf.pojo"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper class="com.iandf.dao.UserMapper"/>
    </mappers>
</configuration>

测试方法

@Test
public void getUserListTest(){
    String resource = "mybatis-config.xml";
    SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    try {
        SqlSessionFactory build = sqlSessionFactoryBuilder.build(Resources.getResourceAsStream(resource));
        SqlSession sqlSession = build.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = userMapper.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

9.2 使用spring整合mybatis开发

9.2.1 导包

junit

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

mybatis

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.2</version>
</dependency>

mysql-connector-java

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>

spring相关

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.10.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.10.RELEASE</version>
</dependency>

aspectJ AOP 织入器

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

mybatis-spring整合包【重点】

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.2</version>
</dependency>

配置Maven静态资源过滤问题！

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

9.2.2 使用方式一基于SqlSessionTemplate

要和 Spring 一起使用 MyBatis，需要在 Spring 应用上下文中定义至少两样东西：一个 SqlSessionFactory 和至少一个数据映射器类。

SqlSessionFactory还需要一个数据源，所指定的映射器类必须是一个接口，而不是具体的实现类。

在 MyBatis 中，你可以使用 SqlSessionFactory 来创建 SqlSession。一旦你获得一个 session 之后，你可以使用它来执行映射了的语句，提交或回滚连接，最后，当不再需要它的时候，你可以关闭 session。使用 MyBatis-Spring 之后，你不再需要直接使用 SqlSessionFactory 了，因为你的 bean 可以被注入一个线程安全的 SqlSession，它能基于 Spring 的事务配置来自动提交、回滚、关闭 session。

编写实体类User

在spring-dao.xml配置文件中配置数据源这里使用的数据源是spring-jdbc依赖下的DriverManagerDataSource。也可以使用dbcp c3po druid

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
 <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
 <property name="url" value="jdbc:mysql://localhost:3306?mybatis/useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf-8"/>
 <property name="username" value="root"/>
 <property name="password" value="123456"/>
</bean>

编写UserMapper和UserMapper.xml 和原生开发一样

在spring-dao.xml配置文件中创建SqlSessionFactory

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
 <property name="dataSource" ref="dataSource"/>
 <!--关联Mybatis配置文件-->
 <property name="configLocation" value="classpath:mybatis-config.xml"/>
 <!--关联mapper文件-->
 <property name="mapperLocations" value="classpath:com/iandf/dao/*.xml"/>
</bean>

在spring-dao.xml配置文件中创建SqlSessionTemplate

<bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
 <!--没有set方法，所以只能是构造器注入-->
 <constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>

编写UserMapper实现类

public class UserMapperImpl implements UserMapper {
 private SqlSessionTemplate sqlSessionTemplate;

 public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
     this.sqlSessionTemplate = sqlSessionTemplate;
 }

 public List<User> getUserList() {
     UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
     return mapper.getUserList();
 }
}

将刚刚写好的spring-dao.xml和UserMapper实现类整合到项目的配置文件中

<?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: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/aop
     http://www.springframework.org/schema/aop/spring-aop.xsd">
     <import resource="spring-dao.xml"/>
     <bean id="userDao" class="com.iandf.dao.UserMapperImpl">
         <property name="sqlSessionTemplate" ref="sqlSessionTemplate"/>
     </bean>
</beans>

编写测试方

@Test
public void springMybatisTest(){
 ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
 UserMapperImpl userDao = context.getBean("userDao", UserMapperImpl.class);
 for (User user : userDao.getUserList()) {
     System.out.println(user);
 }
}

9.2.3 spring整合mybatis开发和原生mybatis开发的区别

在基础的 MyBatis 用法中，是通过 SqlSessionFactoryBuilder 来创建 SqlSessionFactory 的。而在 MyBatis-Spring 中，则使用 SqlSessionFactoryBean 来创建。
在 MyBatis 中，你可以使用 SqlSessionFactory 来创建 SqlSession。一旦你获得一个 session 之后，你可以使用它来执行映射了的语句，提交或回滚连接，最后，当不再需要它的时候，你可以关闭 session。而在spring中，使用sqlSessionFactory来创建sqlSessionTemplate，你可以使用它来执行映射了的语句。
SqlSessionTemplate 是 MyBatis-Spring 的核心。作为 SqlSession 的一个实现，这意味着可以使用它无缝代替你代码中已经在使用的 SqlSession。模板可以参与到 Spring 的事务管理中，并且由于其是线程安全的，可以供多个映射器类使用，你应该总是用 SqlSessionTemplate 来替换 MyBatis 默认的 DefaultSqlSession 实现。在同一应用程序中的不同类之间混杂使用可能会引起数据一致性的问题。
spring需要提供一个UserMapper接口的实现类，实现类组合了一个SqlSessionTemplate对象，有这个对象来对事务进行统一的管理

9.2.4 使用方式二基于SqlSessionDaoSupport

步骤：

编写实体类User
在spring-dao.xml配置文件中配置数据源
编写UserMapper和UserMapper.xml 和原生开发一样
在spring-dao.xml配置文件中创建SqlSessionFactory

编写UserMapper实现类并继承SqlSessionDaoSupport 不用编写SqlSessionTemplate

public class UserMapperImplBySqlSessionDaoSupport extends SqlSessionDaoSupport implements UserMapper {

 public List<User> getUserList() {
     //getSqlSession()返回的是SqlSessionTemplate，只是SqlSessionTemplate实现了SqlSession接口
     return getSqlSession().getMapper(UserMapper.class).getUserList();
 }
}

在applicationContext.xml中注册UserMapperImplBySqlSessionDaoSupport的bean

<bean id="userDao2" class="com.iandf.dao.UserMapperImplBySqlSessionDaoSupport">
 <property name="sqlSessionTemplate" ref="sqlSessionTemplate"/>
</bean>

测试方法

@Test
public void springMybatisTest2(){
 ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
 SqlSessionTemplate sqlSessionTemplate = context.getBean("sqlSessionTemplate", SqlSessionTemplate.class);
 UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
 for (User user : mapper.getUserList()) {
     System.out.println(user);
 }
}

10. spring事务

事务管理分类：

声明式事务：使用aop织入事务，对事务进行管理
编程式事务：在代码中显示的执行事务

10.1 使用aop织入事务

配置生命式事务

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 <property name="dataSource" ref="dataSource"/>
</bean>

配置事务通知需要配置tx命名空间

<!--配置事务通知-->
<tx:advice id="tx_advice" transaction-manager="transactionManager">
 <tx:attributes>
      <!--*：该通知在任意方法上生效，也可以是get*: 以get开头的所有方法生效-->
     <tx:method name="*"/>
 </tx:attributes>
</tx:advice>

配置切入点

 <!--配置接入点-->
 <aop:config>
     <aop:pointcut id="tx_pointcut" expression="execution(* com.iandf.dao.UserMapper.*(..))"/>
     <aop:advisor advice-ref="tx_advice" pointcut-ref="tx_pointcut"/>
 </aop:config>

上面三步做完之后就成功的把事务织入到原来的代码中了

1.1 简介

1.2 优点

1.3 组成

1.4 扩展

2. IOC

2.1 引入IOC

2.2 IOC本质

2.3 IOC创建对象的方式

2.4 spring配置

2.4.1 alias

2.4.2 bean

2.4.3 import

3. spring注入

3.1 简介

3.2 注入方式

3.2.1 构造器注入

3.2.2 set注入{重点}

3.2.3 扩展注入

4. bean作用域

5. 自动装配

5.1 使用xml自动装配

5.2 使用注解自动配置

5.2.1 配置环境

5.2.2 @autowired

5.2.3 @Resource

5.2.4 小结

6. 使用注解开发

6.1 使用注解实现bean配置和属性的注入

6.2 Component的衍生注解

6.3 自动配置注解 看第五章节

6.4 作用域

6.5 小结

7 使用纯java进行配置

8. AOP

8.1 什么是aop

8.2 aop在spring中的作用

8.3 使用spring实现aop

8.3.1 使用spring api 实现

8.3.2 使用自定义类实现aop

8.3.3 使用注解实现aop

9. MyBatis

9.1 mybatis原生开发

9.2 使用spring整合mybatis开发

9.2.1 导包

9.2.2 使用方式一 基于SqlSessionTemplate

9.2.3 spring整合mybatis开发和原生mybatis开发的区别

9.2.4 使用方式二 基于SqlSessionDaoSupport

10. spring事务

10.1 使用aop织入事务

6.3 自动配置注解看第五章节

9.2.2 使用方式一基于SqlSessionTemplate

9.2.4 使用方式二基于SqlSessionDaoSupport