在 Wed 中应用 MyBatis（同时利用MVC架构模式，以及ThreadLocal 事件控制） ...

1. 在 Wed 中应用 MyBatis（同时利用MVC架构模式，以及ThreadLocal 事件控制）

@
目录

• 1. 在 Wed 中应用 MyBatis（同时利用MVC架构模式，以及ThreadLocal 事件控制）
  
• 2. 实现步骤：
  
  
  
  • 1. 第一步：环境搭建
    
  • 2. 第二步：前端页面 index.html
    
  • 3. 第三步：创建pojo包、service包、dao包、web包、utils包，exceptions包
    
  • 4. 第四步：编写 utils 包下的，获取 MyBatis，SqlSesion  连接的工具类
    
  • 5. 第五步：定义pojo类：Account
    
  • 6. 第六步：编写AccountDao接口，以及AccountDaoImpl实现类
    
  • 7. 第七步：AccountDaoImpl 中编写了mybatis 代码，需要编写SQL映射文件了
    
  • 8. 第八步：编写AccountService接口以及AccountServiceImpl
    
  • 9. 第九步：编写 自定义 Exception 非常
    
  • 10. 第十步：编写AccountController
    
  • 11. 第十一步：运行测试：
    
  • 2.1 补充阐明：事件上的处理
    
  
  
• 3. MyBatis焦点对象的作用域
  
  
  
  • 3.1 SqlSessionFactoryBuilder
    
  • 3.2 SqlSessionFactory
    
  • 3.3 SqlSession
    
  
  
• 4. 总结：
  
• 5. 最后：
  

在 Web 中应用 MyBatis ，同时利用 MVC 架构模式，以及对应的 ThreadLocal 事件控制。
实现功能，银行账户的转账功能，同时进行事件上的处理。
需求描述：
实际简单的转账操作：

数据库表的计划和准备数据：

2. 实现步骤：

这里阐明一下，开发可以

• 从后往前
  
• 也可以，从前往后
  

二者没有太大区别，你认为哪个方向更好编写，便按照哪个方向即可，我个人比较风俗从前往后，所以这里我就从前往后了。
1. 第一步：环境搭建

IDEA中创建Maven WEB应用
注意：这里的 Archetype : 选择org.apache.maven.archetypes:maven-archetype-webapp 不要选错了。

IDEA配置Tomcat，这里Tomcat利用10+版本。并部署应用到tomcat。

默认创建的maven web应用没有 java和 resources目录。

一般会自动添加上，如果没有的话，有两种手动添加上的方式：

• 第一种就是：直接在 IDEA 当的 main 目录下，新建
  

• 第二种修改：修改maven-archetype-webapp-1.4.jar中的配置文件
  

这里自动生成的：web.xml 文件的版本较低，内容有点不太合适，我们可以从 tomcat10 的样例文件中复制，然后修改

如下是：tomcat 10 当中的样例：

1. [/code]
2. [list]
3. [*]删除 index.jsp文件，由于我们这个项目不利用JSP。只利用 html。
4. [*]确定 pom.xml 文件中的打包方式是 war 包。
5. [*]引入相关依赖
6. [*]
7. [list]
8. [*]编译器版本修改为 17
9. [*]引入的依赖包括：mybatis，mysql驱动，junit，logback，servlet。
10. [/list]
11. [/list][align=center][img]https://img2024.cnblogs.com/blog/3084824/202406/3084824-20240612222519889-1366275172.png[/img][/align]
12. [code]<?xml version="1.0" encoding="UTF-8"?>
14. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
15.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
16.   <modelVersion>4.0.0</modelVersion>
18.   <groupId>com.rainbowsea</groupId>
19.   <artifactId>mybatis-004-web</artifactId>
20.   <version>1.0-SNAPSHOT</version>
21.   <packaging>war</packaging>
23.   <name>mybatis-004-web Maven Webapp</name>
24.   
25.   <url>http://www.example.com</url>
27.   <properties>
28.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
29.     <maven.compiler.source>1.7</maven.compiler.source>
30.     <maven.compiler.target>1.7</maven.compiler.target>
31.   </properties>
33.   <dependencies>
34.     <dependency>
35.       <groupId>junit</groupId>
36.       <artifactId>junit</artifactId>
37.       <version>4.11</version>
38.       <scope>test</scope>
39.     </dependency>
41.    
42.     <dependency>
43.       <groupId>org.mybatis</groupId>
44.       <artifactId>mybatis</artifactId>
45.       <version>3.5.10</version>
46.     </dependency>
49.     <dependency>
50.       <groupId>mysql</groupId>
51.       <artifactId>mysql-connector-java</artifactId>
52.       <version>8.0.30</version>
53.     </dependency>
56.     <dependency>
57.       <groupId>ch.qos.logback</groupId>
58.       <artifactId>logback-classic</artifactId>
59.       <version>1.2.11</version>
60.     </dependency>
62.    
63.     <dependency>
64.       <groupId>jakarta.servlet</groupId>
65.       <artifactId>jakarta.servlet-api</artifactId>
66.       <version>5.0.0</version>
67.       <scope>provided</scope>
68.     </dependency>
69.   </dependencies>
71.   <build>
72.     <finalName>mybatis-004-web</finalName>
73.     <pluginManagement>
74.       <plugins>
75.         <plugin>
76.           <artifactId>maven-clean-plugin</artifactId>
77.           <version>3.1.0</version>
78.         </plugin>
79.         
80.         <plugin>
81.           <artifactId>maven-resources-plugin</artifactId>
82.           <version>3.0.2</version>
83.         </plugin>
84.         <plugin>
85.           <artifactId>maven-compiler-plugin</artifactId>
86.           <version>3.8.0</version>
87.         </plugin>
88.         <plugin>
89.           <artifactId>maven-surefire-plugin</artifactId>
90.           <version>2.22.1</version>
91.         </plugin>
92.         <plugin>
93.           <artifactId>maven-war-plugin</artifactId>
94.           <version>3.2.2</version>
95.         </plugin>
96.         <plugin>
97.           <artifactId>maven-install-plugin</artifactId>
98.           <version>2.5.2</version>
99.         </plugin>
100.         <plugin>
101.           <artifactId>maven-deploy-plugin</artifactId>
102.           <version>2.8.2</version>
103.         </plugin>
104.       </plugins>
105.     </pluginManagement>
106.   </build>
107. </project>

复制代码

• 引入相关配置文件，放到resources目录下（全部放到类的根路径下）
  
• 
  
  
  
  • mybatis-config.xml
    
  • AccountMapper.xml
    
  • logback.xml
    
  • jdbc.properties
    
  
  
• 
  
  
• 
  
• logback.xml  logbak 日志框架信息
  
• 
  
  
• 1. <?xml version="1.0" encoding="UTF-8"?>
  3. <configuration debug="false">
  4.    
  5.     <appender name="STDOUT" >
  6.         <encoder >
  7.             
  8.             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
  9.         </encoder>
  10.     </appender>
  12.    
  13.     <logger name="com.apache.ibatis" level="TRACE"/>
  14.     <logger name="java.sql.Connection" level="DEBUG"/>
  15.     <logger name="java.sql.Statement" level="DEBUG"/>
  16.     <logger name="java.sql.PreparedStatement" level="DEBUG"/>
  18.    
  19.     <root level="DEBUG">
  20.         <appender-ref ref="STDOUT"/>
  21.         <appender-ref ref="FILE"/>
  22.     </root>
  24. </configuration>

  复制代码
• AccountMapper.xml  SQl语句的映射文件
  
• 1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.                 PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.                 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  6. <mapper namespace="account">
  7.         <select id="selectByActno" resultType="com.rianbowsea.bank.pojo.Account">
  8.                 select * from t_act where actno = #{actno}
  9.         </select>
  12.         <update id="updateByActno">
  13.                 update t_act set balance = #{balance} where actno = #{actno}
  14.         </update>
  16. </mapper>

  复制代码
• 
  
• jdb.properties  数据库连接信息的配置文件
  
• 1. jdbc.driver=com.mysql.cj.jdbc.Driver
  2. jdbc.url=jdbc:mysql://localhost:3306/mybatis
  3. jdbc.username=root
  4. jdbc.password=MySQL123

  复制代码
• mybatis-config.xml  MyBatis 的焦点配置文件
  
• 1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration
  3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <configuration>
  6.    
  7.     <properties resource="jdbc.properties"></properties>
  8.     <environments default="mybatis">
  9.         <environment id="mybatis">
  10.             <transactionManager type="JDBC"/>
  11.             <dataSource type="POOLED">
  12.                 <property name="driver" value="${jdbc.driver}"/>
  13.                 <property name="url" value="${jdbc.url}"/>
  14.                 <property name="username" value="${jdbc.username}"/>
  15.                 <property name="password" value="${jdbc.password}"/>
  16.             </dataSource>
  17.         </environment>
  18.     </environments>
  19.     <mappers>
  20.         <mapper resource="AccountMapper.xml"/>
  21.     </mappers>
  22. </configuration>

  复制代码

2. 第二步：前端页面 index.html

在Tomcat当中 ，index.html 默认就是开始页面，主页的。

1. <!DOCTYPE html>
2. <html lang="en">
3. <head>
4.     <meta charset="UTF-8">
5.     <title>银行账户转账</title>
6. </head>
7. <body>
8. <form action="/bank/transfer" method="post">
9.     转出账户:<input type="text" name="fromActno">
   
11.     转入账户:<input type="text" name="toActno">
    
13.     转账金额:<input type="text" name="money">
    
15.     <input type="submit" value="转账">
17. </form>
18. </body>
19. </html>

复制代码

3. 第三步：创建pojo包、service包、dao包、web包、utils包，exceptions包

4. 第四步：编写 utils 包下的，获取 MyBatis，SqlSesion  连接的工具类

1. package com.rianbowsea.bank.utils;
4. import org.apache.ibatis.io.Resources;
5. import org.apache.ibatis.session.SqlSession;
6. import org.apache.ibatis.session.SqlSessionFactory;
7. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
9. import java.io.IOException;
11. public class SqlSessionUtil {
12.     // 工具类的构造方法一般都是私有话化的
13.     // 工具类中所有的方法都是静态的，直接类名即可调用，不需要 new 对象
14.     // 为了防止new对象，构造方法私有化。
16.     private SqlSessionUtil() {
18.     }
21.     private static SqlSessionFactory sessionFactory = null;
23.     // 静态代码块，类加载时执行
24.     // SqlSessionUtil 工具类在进行第一次加载的时候，解析mybatis-config.xml 文件，创建SqlSessionFactory对象。
25.     static {
26.         // 获取到  SqlSessionFactoryBuilder 对象
27.         SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
29.         // 获取到SqlSessionFactory 对象
30.         // SQlsessionFactory对象，一个SqlSessionFactory对应一个 environment, 一个environment通常是一个数据库
31.         try {
32.             sessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml"));
33.         } catch (IOException e) {
34.             throw new RuntimeException(e);
35.         }
37.     }
40.     // 全局的，服务器级别的，一个服务器当中定义一个即可
41.     private static ThreadLocal<SqlSession> local = new ThreadLocal<>();
43.     /**
44.      * 获取会话对象
45.      *
46.      * @return SqlSession
47.      */
48.     public static SqlSession openSession() {
49.         // 先从 ThreadLocal 当中获取，获取到 SqlSession 对象
50.         SqlSession sqlSession = local.get();
52.         if (null == sqlSession) {
53.             // ThreadLocat 没有就， 创建一个
54.             sqlSession = sessionFactory.openSession();
55.             // 同时将其设置到 ThreadLocal容器当中,将SqlSession对象绑定到当前线程上
56.             local.set(sqlSession);
57.         }
59.         return sqlSession;
60.     }
63.     /**
64.      * 关闭SqlSession 对象（从当前线程中移除SqlSession 对象）
65.      * @param sqlSession
66.      */
67.     public static void close(SqlSession sqlSession) {
68.         if(sqlSession != null) {
69.             // 1.先将其关闭
70.             sqlSession.close();
71.             // 2. 再将其当前线程移除ThreadLocal 当前线程外面，防止被其他线程拿到整个没用的线程
72.             local.remove();
73.             /*
74.             注意：移除SqlSession 对象和当前线程的绑定关系
75.             因为Tomcat 服务器是支持线程池的，也就是说，用过的先吃对象t1，可能下一I此还会使用整个t1(已经关闭，没用的)线程。
76.              */
77.         }
78.     }
79. }

复制代码

5. 第五步：定义pojo类：Account

对于 pojo 当中的类，一定要有 set 和 get  方法，以及无参数构造方法，不然，大部分的框架是无法通过反射机制，进行操作的，从而出现错误的。

1. package com.rianbowsea.bank.pojo;
4. /**
5. * 账户类，封装账户数据
6. */
7. public class Account {
8.     private Long id;
9.     private String actno;
10.     private Double balance;
13.     public Account() {
14.     }
16.     public Account(Long id, String actno, Double balance) {
17.         this.id = id;
18.         this.actno = actno;
19.         this.balance = balance;
20.     }
22.     @Override
23.     public String toString() {
24.         return "Account{" +
25.                 "id=" + id +
26.                 ", actno='" + actno + '\'' +
27.                 ", balance=" + balance +
28.                 '}';
29.     }
31.     public Long getId() {
32.         return id;
33.     }
35.     public void setId(Long id) {
36.         this.id = id;
37.     }
39.     public String getActno() {
40.         return actno;
41.     }
43.     public void setActno(String actno) {
44.         this.actno = actno;
45.     }
47.     public Double getBalance() {
48.         return balance;
49.     }
51.     public void setBalance(Double balance) {
52.         this.balance = balance;
53.     }
54. }

复制代码

6. 第六步：编写AccountDao接口，以及AccountDaoImpl实现类

分析dao中至少要提供几个方法，才能完成转账：

• 转账前需要查询余额是否充足：selectByActno
  
• 转账时要更新账户：update
  

AccountDao

1. package com.rianbowsea.bank.dao;
4. import com.rianbowsea.bank.pojo.Account;
6. /**
7. * 账户的DAO对象，负责t_act 表中数据的CRUD，一般一个表对应一个 DAO
8. * 强调以下，DAO对象中的任何一个方法和业务不挂钩，没有任何业务逻辑在里头
9. * DAo中的方法就是CRUD的，所以方法名大部分是：insertXxx,deletexxx,updatexxx,selectxxx
10. */
11. public interface AccountDao {
13.     /**
14.      * 根据账号查询账户信息
15.      * @param actno 账号
16.      * @return 账户信息
17.      */
18.     Account selectActno(String actno);
21.     /**
22.      * 更新账户信息
23.      * @param account 被更新的账户信息
24.      * @return 1表示更新成功，其他表示更新失败
25.      */
26.     int updateByActno(Account account);
29. }

复制代码

AccountDaoImpl

1. package com.rianbowsea.bank.dao.impl;
3. import com.rianbowsea.bank.dao.AccountDao;
4. import com.rianbowsea.bank.pojo.Account;
5. import com.rianbowsea.bank.utils.SqlSessionUtil;
6. import org.apache.ibatis.session.SqlSession;
8. public class AccountDaoImpl implements AccountDao {
9.     private SqlSession sqlSession = SqlSessionUtil.openSession();
11.     @Override
12.     public Account selectActno(String actno) {
13.         Account account = (Account) sqlSession.selectOne("account.selectByActno", actno);
14.         // 注意：事务的控制，都是放在业务层的，不是放在持久层DAo，更不放在utils工具层
15.         //sqlSession.close();
16.         return account;
17.     }
19.     @Override
20.     public int updateByActno(Account account) {
23.         int count = sqlSession.update("account.updateByActno", account);
24.         // 注意：事务的控制，都是放在业务层的，不是放在持久层DAo，更不放在utils工具层
25.         //sqlSession.commit();  // 提交数据
26.         //sqlSession.close();
27.         return count;
28.     }
29. }

复制代码

7. 第七步：AccountDaoImpl 中编写了mybatis 代码，需要编写SQL映射文件了

AccountMapper.xml

1. <?xml version="1.0" encoding="UTF-8" ?>
2. <!DOCTYPE mapper
3.                 PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4.                 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
6. <mapper namespace="account">
7.         <select id="selectByActno" resultType="com.rianbowsea.bank.pojo.Account">
8.                 select * from t_act where actno = #{actno}
9.         </select>
12.         <update id="updateByActno">
13.                 update t_act set balance = #{balance} where actno = #{actno}
14.         </update>
16. </mapper>

复制代码

8. 第八步：编写AccountService接口以及AccountServiceImpl

AccountService

1. package com.rianbowsea.bank.service;
4. import com.rianbowsea.bank.exceptions.MoneyNotEnoughException;
5. import com.rianbowsea.bank.exceptions.TransferException;
7. /**
8. * 注意: 业务类当中的业务方法的名字在起名字的时候，最好见名知意，能够体现出具体的业务是做什么的
9. * 账户业务类
10. */
11. public interface AccountService {
13.     /**
14.      * 账户转账业务
15.      *
16.      * @param fromActno 转出账户
17.      * @param toActno   转入账户
18.      * @param money     转账金额
19.      */
20.     void transfer(String fromActno, String toActno, double money) throws MoneyNotEnoughException, TransferException;
22. }

复制代码

AccountServiceImpl

1. package com.rianbowsea.bank.service.impl;
3. import com.rianbowsea.bank.dao.AccountDao;
4. import com.rianbowsea.bank.dao.impl.AccountDaoImpl;
5. import com.rianbowsea.bank.exceptions.MoneyNotEnoughException;
6. import com.rianbowsea.bank.exceptions.TransferException;
7. import com.rianbowsea.bank.pojo.Account;
8. import com.rianbowsea.bank.service.AccountService;
9. import com.rianbowsea.bank.utils.SqlSessionUtil;
10. import org.apache.ibatis.session.SqlSession;
12. public class AccountServiceImpl implements AccountService {
14.     private AccountDao accountDao = new AccountDaoImpl();
16.     @Override
17.     public void transfer(String fromActno, String toActno, double money) throws MoneyNotEnoughException, TransferException {
19.         // 添加事务控制代码
20.         SqlSession sqlSession = SqlSessionUtil.openSession();
23.         // 1.判断转出账户的金额是否充足(select)
24.         Account fromAct = accountDao.selectActno(fromActno);
26.         if (fromAct.getBalance() < money) {
27.             // 2.如果转出账户余额不足，提示用户
28.             throw new MoneyNotEnoughException("对不起，余额不足");
29.         }
31.         // 3. 如果转出账户余额充足，更新转出账户的余额（update）
32.         // 先在内存当中修改
33.         Account toACt = accountDao.selectActno(toActno);
34.         toACt.setBalance(toACt.getBalance() + money);
35.         fromAct.setBalance(fromAct.getBalance() - money);
37.         // 4. 更新转入账户的余额(update)
38.         int count = accountDao.updateByActno(toACt);
39.         count += accountDao.updateByActno(fromAct);
41.         // 模拟异常
42.         //String s = null;
43.         //s.toString();
45.         if(count !=2) {
46.             throw new TransferException("转账异常，未知原因");
47.         }
49.         // 注意：事务的控制，都是放在业务层的，不是放在持久层DAo，更不放在utils工具层
50.         sqlSession.commit(); // 提交数据
51.         sqlSession.close();
52.     }
55. }

复制代码

9. 第九步：编写 自定义 Exception 非常

MoneyNotEnoughException

1. package com.rianbowsea.bank.exceptions;
4. /**
5. * 余额不足异常
6. */
7. public class MoneyNotEnoughException extends Exception{
8.     public MoneyNotEnoughException() {
9.     }
11.     public MoneyNotEnoughException(String message) {
12.         super(message);
13.     }
14. }

复制代码

TransferException

1. package com.rianbowsea.bank.exceptions;
4. /**
5. * 转账异常
6. */
7. public class TransferException extends Exception{
8.     public TransferException() {
9.     }
11.     public TransferException(String message) {
12.         super(message);
13.     }
14. }

复制代码

10. 第十步：编写AccountController

AccountController

1. package com.rianbowsea.bank.web;
3. import com.rianbowsea.bank.exceptions.MoneyNotEnoughException;
4. import com.rianbowsea.bank.exceptions.TransferException;
5. import com.rianbowsea.bank.service.AccountService;
6. import com.rianbowsea.bank.service.impl.AccountServiceImpl;
7. import jakarta.servlet.ServletException;
8. import jakarta.servlet.annotation.WebServlet;
9. import jakarta.servlet.http.HttpServlet;
10. import jakarta.servlet.http.HttpServletRequest;
11. import jakarta.servlet.http.HttpServletResponse;
13. import java.io.IOException;
16. @WebServlet("/transfer")
17. public class AccountServlet extends HttpServlet {
18.     // 为了让整个对象在其他方法中可以用，声明为实例变量
19.     private AccountService accountService = new AccountServiceImpl();
21.     @Override
22.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,
23.             IOException {
25.         // 获取表单数据
26.         String fromActno = request.getParameter("fromActno");
27.         String toActno = request.getParameter("toActno");
28.         double money = Double.parseDouble(request.getParameter("money"));
30.         // 转账业务
31.         try {
32.             // 调用service的转账方法完成转账，（调用业务层）
33.             accountService.transfer(fromActno,toActno,money);
34.             // 程序能够走到这里，表示转账一定成功了
35.             // 调用View完成展示结果
36.             response.sendRedirect(request.getContextPath()+"/success.html");
37.         } catch (MoneyNotEnoughException e) {
38.             response.sendRedirect(request.getContextPath()+"/error.html");
39.             throw new RuntimeException(e);
40.         } catch (TransferException e) {
41.             response.sendRedirect(request.getContextPath()+"/error2.html");
42.             throw new RuntimeException(e);
43.         } catch (NullPointerException e) {
44.             response.sendRedirect(request.getContextPath()+"/error2.html");
45.             throw new RuntimeException(e);
46.         }
48.     }
49. }

复制代码

11. 第十一步：运行测试：

首先测试，没有模拟非常，看是否可以转账乐成。

模拟非常，看事件上的处理，是否乐成，是否能乐成回滚，是否会丢失数据 。

2.1 补充阐明：事件上的处理

在之前的转账业务中，更新了两个账户，我们需要包管它们的同时乐成或同时失败，这个时候就需要利用事件机制，在 transfer 方法开始执行时开启事件，直到两个更新都乐成之后 ，为了包管service和dao中利用的SqlSession对象是同一个，可以将SqlSession对象存放到ThreadLocal当中。

注意：移除SqlSession 对象和当前线程的绑定关系
由于Tomcat 服务器是支持线程池的，也就是说，用过的先吃对象t1，可能下一I此还会利用整个t1(已经关闭，没用的)线程。

注意：事件的控制，都是放在业务层的，不是放在持久层DAo，更不放在utils工具层 .

3. MyBatis焦点对象的作用域

3.1 SqlSessionFactoryBuilder

这个类可以被实例化、利用和抛弃，一旦创建了 SqlSessionFactory，就不再需要它了。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。 你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但最好照旧不要不停保存着它，以包管所有的 XML 解析资源可以被释放给更重要的事情。
3.2 SqlSessionFactory

SqlSessionFactory 一旦被创建就应该在应用的运行期间不停存在，没有任何理由抛弃它或重新创建另一个实例。  利用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重修 SqlSessionFactory 被视为一种代码“坏风俗”。因此 SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到，最简单的就是利用单例模式或者静态单例模式。
3.3 SqlSession

每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。 绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不可。 也绝不能将 SqlSession 实例的引用放在任何范例的托管作用域中，比如 Servlet 框架中的 HttpSession。 如果你现在正在利用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个相应后，就关闭它。 这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中。 下面的示例就是一个确保 SqlSession 关闭的标准模式：

1. try (SqlSession session = sqlSessionFactory.openSession()) {
2.   // 你的应用逻辑代码
3. }

复制代码

4. 总结：

• 为了包管 service 和 dao 中利用的SqlSession对象是同一个，可以将SqlSession对象存放到ThreadLocal当中。
  

• 注意：移除SqlSession 对象和当前线程的绑定关系
  由于Tomcat 服务器是支持线程池的，也就是说，用过的先吃对象t1，可能下一I此还会利用整个t1(已经关闭，没用的)线程。
  

• 注意：事件的控制，都是放在业务层的，不是放在持久层DAo，更不放在utils工具层 .
  
• SqlSessionFactoryBuilder: 这个类可以被实例化、利用和抛弃，一旦创建了 SqlSessionFactory，就不再需要它了。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。
  
• SqlSessionFactory 一旦被创建就应该在应用的运行期间不停存在，没有任何理由抛弃它或重新创建另一个实例。
  
• SqlSession 它的最佳的作用域是请求或方法作用域**。 绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不可。 **也绝不能将 SqlSession 实例的引用放在任何范例的托管作用域中，比如 Servlet 框架中的 HttpSession。 如果你现在正在利用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。
  

5. 最后：

“在这个最后的篇章中，我要表达我对每一位读者的感激之情。你们的关注和回复是我创作的动力源泉，我从你们身上吸取了无尽的灵感与勇气。我会将你们的鼓励留在心底，继续在其他的领域奋斗。感谢你们，我们总会在某个时候再次相遇。”

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。