Spring学习记录 Day3（Spring拓展）

矫情吗；* 2021-11-16 12:44 311阅读 0赞

### 文章目录 ###

*  Day 3
 *  整合Mybatis
 *   *  回忆Mybatis
     *  Mybatis和Spring整合
 *  声明式事务
 *   *  事务
     *  测试
     *  声明式事务
     *  Spring配置事务
     *  总结
 *  使用注解开发
 *   *  bean
     *  IOC注入
     *  自动装配
     *  作用域
     *  注解和XML对比
     *  注解xml可以整合开发

# Day 3 #

2019年7月28日。  
这是我学习Spring的第三天。  
这一天，我学到了以下的知识。

# 整合Mybatis #

步骤：

*  导包
 *  编写配置文件
 *  编写代码

## 回忆Mybatis ##

1.  导包：mybatis、数据库驱动包、junit，代码如下：
    
        <dependencies>
            
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.11</version>
            </dependency>
        
            
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.5.1</version>
            </dependency>
        
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
        </dependencies>
    
    记得导入build标签，不然maven无法识别xml文件，代码如下：
    
        <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>
2.  编写实体类User，代码如下：
    
        package pojo;
        
        public class User { 
        
        private int id;
        private String name;
        private String pwd;
        
        public User() { 
        }
        
        public User(int id, String name, String pwd) { 
            this.id = id;
            this.name = name;
            this.pwd = pwd;
        }
        
        public int getId() { 
            return id;
        }
        
        public void setId(int id) { 
            this.id = id;
        }
        
        public String getName() { 
            return name;
        }
        
        public void setName(String name) { 
            this.name = name;
        }
        
        public String getPwd() { 
            return pwd;
        }
        
        public void setPwd(String pwd) { 
            this.pwd = pwd;
        }
        
        @Override
        public String toString() { 
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", pwd='" + pwd + '\'' +
                    '}';
        }
        }
3.  编写mybatis配置文件，代码如下：
    
        <?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>
        
        <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&useUnicode=true&charsetEncoding=UTF-8"/>
                    <property name="username" value="root"/>
                    <property name="password" value="123456"/>
                </dataSource>
            </environment>
        </environments>
        
        <mappers>
            <mapper resource="dao/UserMapper.xml"/>
        </mappers>
        </configuration>
4.  编写dao接口UserDao，里面只有一个方法，代码如下：
    
        import pojo.User;
        
        import java.util.List;
        
        public interface UserDao { 
        
        // 获取用户列表
        List<User> selectUserList();
        }
5.  编写接口对应的mapper映射文件UserMapper，代码如下：
    
        <?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="dao.UserDao">
        <select id="selectUserList" resultType="pojo.User" >
            select * from mybatis.user;
        </select>
        </mapper>
6.  在配置文件中注册映射文件，代码如下：
    
        <mappers>
            <mapper resource="dao/UserMapper.xml"/>
        </mappers>
7.  编写测试类UserDaoTest，代码如下：
    
        public class UserDaoTest { 
        
        @Test
        public void Test() throws IOException { 
            String resources = "mybatis-config.xml";
            InputStream in = Resources.getResourceAsStream(resources);
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
            SqlSession sqlSession = sqlSessionFactory.openSession();
            UserDao mapper = sqlSession.getMapper(UserDao.class);
            List<User> userList = mapper.selectUserList();
        
            for (User user : userList) { 
                System.out.println(user);
            }
        }
        }

## Mybatis和Spring整合 ##

**概念**

**有一个包很重要：mybatis-spring**

MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。

在开始使用 MyBatis-Spring 之前，你需要先熟悉 Spring 和 MyBatis 这两个框架和有关它们的术语。这很重要——因为本手册中不会提供二者的基本内容，安装和配置教程。

MyBatis-Spring 需要以下版本：

<table> 
 <thead> 
  <tr> 
   <th align="left">MyBatis-Spring</th> 
   <th align="left">MyBatis</th> 
   <th align="left">Spring 框架</th> 
   <th align="left">Spring Batch</th> 
   <th align="left">Java</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">2.0</td> 
   <td align="left">3.5+</td> 
   <td align="left">5.0+</td> 
   <td align="left">4.0+</td> 
   <td align="left">Java 8+</td> 
  </tr> 
  <tr> 
   <td align="left">1.3</td> 
   <td align="left">3.4+</td> 
   <td align="left">3.2.2+</td> 
   <td align="left">2.1+</td> 
   <td align="left">Java 6+</td> 
  </tr> 
 </tbody> 
</table>

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

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

在 MyBatis-Spring 中，可使用 `SqlSessionFactoryBean`来创建 `SqlSessionFactory`。 要配置这个工厂 bean，只需要把下面代码放在 Spring 的 XML 配置文件中：

注意：`SqlSessionFactory` 需要一个 `DataSource`（数据源）。 这可以是任意的 `DataSource`，只需要和配置其它 Spring 数据库连接一样配置它就可以了。

在基础的 MyBatis 用法中，是通过 `SqlSessionFactoryBuilder` 来创建 `SqlSessionFactory` 的。 而在 MyBatis-Spring 中，则使用 `SqlSessionFactoryBean` 来创建。

`mapperLocations` 属性接受多个资源位置。这个属性可以用来指定 MyBatis 的映射器 XML 配置文件的位置。

需要注意的是，这个配置文件**并不需要**是一个完整的 MyBatis 配置。确切地说，任何环境配置（`<environments>`），数据源（`<DataSource>`）和 MyBatis 的事务管理器（`<transactionManager>`）都会被**忽略**。`SqlSessionFactoryBean` 会创建它自有的 MyBatis 环境配置（`Environment`），并按要求设置自定义环境的值。

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

**`SqlSessionTemplate` 是 MyBatis-Spring 的核心。**

作为 `SqlSession` 的一个实现，这意味着可以使用它无缝代替你代码中已经在使用的 `SqlSession`。`SqlSessionTemplate` 是线程安全的，可以被多个 DAO 或映射器所共享使用。

可以使用 `SqlSessionFactory` 作为构造方法的参数来创建 `SqlSessionTemplate` 对象。

**思考问题？为什么使用构造器，而不直接属性；因为没有对应set方法；**

现在，这个 bean 就可以直接注入到你的 DAO bean 中了。你需要在你的 bean 中添加一个 SqlSession 属性，就像下面这样：

public class UserDaoImpl implements UserDao { 
    
      private SqlSession sqlSession;
    
      public void setSqlSession(SqlSession sqlSession) { 
        this.sqlSession = sqlSession;
      }
    
      public User getUser(String userId) { 
        return sqlSession.selectOne("org.mybatis.spring.sample.mapper.UserMapper.getUser", userId);
      }
    }

**实现**

1.  导包：
    
     *  mybaits
     *  mysql驱动
     *  junit
     *  spring-core
     *  spring-beans
     *  spring-context
     *  spring-jdbc 【数据源】
     *  spring-tx 【事务】
     *  mybatis-spring整合包 【最重要】
     *  …
2.  配置mybatis文件，只需要写一些简单的 设置，别名，mapper映射文件，代码如下：

<?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="pojo"/>
        </typeAliases>
    
        
        <mappers>
            <mapper resource="dao/UserMapper.xml"/>
        </mappers>
    
    </configuration>

1.  编写spring配置文件
    
    1.  数据源配置
    
        
        <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&useUnicode=true&characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
        </bean>
    
    1.  sqlSessionFactory配置
    
        
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        </bean>
    
    1.  sqlSession配置
    
        
        <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory" />
        </bean>
    
    1.  接口实现类增加一个属性：sqlSession
    
        public class UserDaoImpl implements UserDao{ 
        
        private SqlSessionTemplate sqlSession;
        
        public void setSqlSession(SqlSessionTemplate sqlSession) { 
            this.sqlSession = sqlSession;
        }
        
        public List<User> selectUser() { 
        
            UserDao mapper = sqlSession.getMapper(UserDao.class);
            return mapper.selectUser();
        
        }
        
        }
    
    1.  将接口的实现类交给spring来管理
    
        
        <bean id="userDaoImpl" class="dao.UserDaoImpl">
        <property name="sqlSession" ref="sqlSession"/>
        </bean>
2.  编写测试类，代码如下：

@Test
    public void test(){ 
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    
        UserDao userDaoImpl = (UserDao) context.getBean("userDaoImpl");
        List<User> users = userDaoImpl.selectUser();
    
        for (User user : users) { 
            System.out.println(user);
        }
    }

# 声明式事务 #

aop：横向编程。日志，**事务**，安全…

## 事务 ##

**事务在项目开发过程中非常重要**！涉及到数据的一致性问题，不容马虎！

事务：要么都成功！要么都不成功！

事务四大特性：ACID ：原子性、一致性、隔离性、持久性。

## 测试 ##

添加一个add和delete方法；

delete的sql故意写错，那么执行删除一定不会成功！

但是插入进去了！（因为没有开启事务处理）

## 声明式事务 ##

Spring支持两种事务处理机制：

编程式事务：把所有事务的代码写在业务中；

声明式事务：使用AOP横切进去；**一般都会使用声明式事务**

要开启 Spring 的事务处理功能，在 Spring 的配置文件中创建一个 `DataSourceTransactionManager` 对象：

使用Spring进行事务通知，需要导入约束文件：tx

事务传播的级别：

Propagation ：key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。有以下选项可供使用：

*  **PROPAGATION\_REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择，默认选择**
 *  PROPAGATION\_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。
 *  PROPAGATION\_MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。
 *  PROPAGATION\_REQUIRES\_NEW：新建事务，如果当前存在事务，把当前事务挂起。
 *  PROPAGATION\_NOT\_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
 *  PROPAGATION\_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。

## Spring配置事务 ##

1.  导包，导入aspectjweaver包，实现AOP
2.  需要配置一个事务管理器，参数需要一个数据源，代码如下：
    
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <constructor-arg ref="dataSource" />
        </bean>
3.  配置声明事务通知，代码如下：
    
        
        <tx:advice id="txAdvice" transaction-manager="transactionManager">
            <tx:attributes>
                
                <tx:method name="add" propagation="REQUIRED"/>
                <tx:method name="delete" propagation="REQUIRED"/>
                <tx:method name="get*" read-only="true"/>
                <tx:method name="*" propagation="REQUIRED"/>
        
            </tx:attributes>
        </tx:advice>
4.  配置aop织入事务，代码如下：
    
        
        <aop:config>
            
            <aop:pointcut id="txPointCut" expression="execution(* dao.UserDaoImpl.*(..))"/>
            
            <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
        </aop:config>

## 总结 ##

**思考：为什么需要配置事务？**

**事务在项目开发过程中非常重要**！涉及到数据的一致性问题，不容马虎！

# 使用注解开发 #

## bean ##

1.  使用注解开发需要导入spring的一系列包；
2.  **需要在配置文件中加一个约束：context；**，代码如下：
    
        <?xml version="1.0" encoding="UTF-8"?>
        <beans xmlns="http://www.springframework.org/schema/beans" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" 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/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
3.  配置扫描组件，代码如下：
    
        
        <context:component-scan base-package="demo"/>
4.  编写代码：
    
        //等价于：<bean id="user" class=demo.User"/>
        
        /* @Component : 组件 bean @Controller ：web层 @Service ： service层 @Repository ：dao层 */
        
        @Component("user")
        public class User { 
            public String name = "秦疆1号";
        }

## IOC注入 ##

1.  可以不用提供set方法，可以直接在属性名上添加一个@Values（值），代码如下：

@Controller("user2")
    public class User2 { 
        // <bean class="demo.User2" id="user2">
        // <property name="name" value="秦疆2号"/>
        // </bean>
    
        @Value("秦疆")
        private String name;
    
        public String getName() { 
            return name;
        }
    }

1.  加入set，直接在set方法上面加上@Values（值），代码如下：

@Controller("user2")
    public class User2 { 
        // <bean class="demo.User2" id="user2">
        // <property name="name" value="秦疆2号"/>
        // </bean>
    
    
        private String name;
    
        public String getName() { 
            return name;
        }
        
        @Value("秦疆")
        public void setName(String name) { 
            this.name = name;
        }
    }

## 自动装配 ##

@Component("user3")
    public class User3 { 
    
        @Value("秦疆3号")
        public String name;
    /* @Autowired //自动注入按照类型匹配，如果存在两个自动匹配对象的值，则无法匹配； @Qualifier("dog1") public Dog dog; */
    
    
        //不是spring的包，是annotation的包；
        @Resource(name = "dog1")
        public Dog dog;
    }

## 作用域 ##

@Scope("prototype") //Spring默认是单例模式的，如果要改成多例模式，加上作用域prototype即可

@Scope("prototype")
    @Component("user3")
    public class User3 { 
    
    }

## 注解和XML对比 ##

*  **xml可以适用于任何场景，结构清晰，推荐使用。**
 *  注解不是自己提供的类，存在局限性；好处：开发简单，方便

## 注解xml可以整合开发 ##

xml和注解的最佳实践：

*  **xml管理bean**
 *  **注解完成属性的注入**