MyBatis（总结，超详细）

最新推荐文章于 2024-06-12 21:52:13 发布

bixiaoya123

最新推荐文章于 2024-06-12 21:52:13 发布

阅读量590

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/bixiaoya123/article/details/109477903

版权

笔记专栏收录该内容

15 篇文章 2 订阅

订阅专栏

MyBatis

ssm开发动态web项目

myBatis 实现Java语言持久化存储代替JDBC，不是web独有的，在普通Java中也可用

传统JDBC操作的缺陷？
1.代码存在大量重复性操作
2.数据库连接创建，释放频繁造成代码不易维护，实际应用SQL变化的可能性较大，SQL变动需要改变Java代码
3.查询操作时，需要手动将结果集中的数据封装到实体中，插入操作时，需要手动将实体的数据设置到SQL语句的占位符位置

解决⽅案：
使⽤⼯具类对相同的操作进⾏抽取；
使⽤数据库连接池初始化连接资源（c3p0、druid）；
将SQL语句抽取到xml配置⽂件中；
使⽤反射、内省等底层技术，实现对象的属性和表的字段⾃动映射。

MyBatis是什么?
MyBatis是⼀个优秀的基于java的持久层框架，它内部封装了JDBC，使开发者只需要关注SQL语句本⾝，⽽不需要花费精⼒去处理加载驱动、创建连接、创建statement等繁杂的过程。
简单说就是：有⼀种叫MyBatis的持久层技术，能够代替JDBC，简化JDBC开发。

ORM(O/RM O/R mapping)
ORM对象关系映射，是⼀种程序设计技术，⽤于实现⾯向对象编程语⾔⾥不同类型系统的数据之间的转换。从效果上说，它其实是创建了⼀个可在编程语⾔⾥使⽤的“虚拟对象数据库”。
简单的说：就是把数据库的表和实体类以及实体类的属性对应起来，让我们可以操作实体类实现操作数据库

MyBatis
MyBatis开发步骤
1.新建项目，导入jar包
2.创建user表，设置id自增
3.编写user实体类
（表示用户的实体类，属性名和数据库表名对应，符合JavaBean的规范）
4.编写映射文件UserMapper.xml DTD约束，规范
5.编写核心配置文件sqlMapConfig.xml，properties（属性）environment（环境）mapppers（映射器）
name，指定为包下的类指定别名
Java。lang.String string
environment环境
Mapper（映射器）
6.编写测试类
7.测试

JavaBean的规范
1.所有的属性private 2.get/set 3.默认的⽆参的构造⽅法 4.toString

myBatis配置顺序

configuration配置
properties属性
setting设置
typeAliases类型别名
typeHandlers类型处理器
objectFactory对象工厂
plugins插件
environment环境配置
transactionManager事务管理器
databaseldProvider数据库厂商标识
mapper映射器

sql片段抽取

<!--SQL语句抽取-->
    <sql id="sql1">
    <!--抽取内容-->
        SELECT * FROM user
    </sql>

编写核心配置文件(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>
    <!--引入外部配置环境-->
    <properties resource="jdbc.properties"/>
    <!--配置别名-->
    <typeAliases>
        <!--name指定为那个包下的别名（别名为类名首字母小写）-->
        <package name="com.hpe.bean"/>
        <!-- 注册类型转换器 -->
    <typeHandlers>
        <typeHandler handler="com.hpe.handler.DateTypeHandler" />
    </typeHandlers>

    <!-- 配置分页插件 -->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageHelper">
            <!-- 配置分页插件的方言 -->
            <property name="dialect" value="mysql" />
        </plugin>
    </plugins>
    </typeAliases>
    <!--配置环境（支持多环境配置，通常只配置一个环境）
    default默认环境-->
    <environments default="dev">
    <!-- id：环境的id -->
        <environment id="dev">
            <!--配置事务管理器-->
            <!-- type：事务管理器类型，类型有如下两种。 JDBC：这个配置就是直接使用了JDBC的提交和回滚设置，它依赖于从数据源得到的连接来管理事 务作用域。 
            MANAGED：这个配置几乎没做什么。它从来不提交或回滚一个连接，而是让容器来管理事务的整 个生命周期。
             默认情况下它会关闭连接，然而一些容器并不希望这样，因此需要将 closeConnection属性设置为false来阻止它默认的关闭行为。 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- type：指定数据源类型，类型有如下三种。
             UNPOOLED：这个数据源的实现只是每次被请求时打开和关闭连接。
              POOLED：这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来。
               JNDI：这个数据源的实现是为了能在如EJB或应用服务器这类容器中使用， 容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的引用。 -->
            <!--配置数据源的基本参数-->
            <dataSource type="POOLED">
            <!-- 使用${key}引用外部配置环境properties文件中的值 -->
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--加载映射文件（使用相对路径的资源引用）-->
        <mapper resource="com/hpe/mapper/UserMapper.xml"></mapper>
    </mappers>
</configuration>

mapper标签该标签的作⽤是加载映射⽂件，加载⽅式有如下⼏种：

使⽤相对于类路径的资源引⽤，例如：

<mapper resource="org/mybatis/builder/AuthorMapper.xml"/>

使⽤完全限定资源定位符（URL），例如：

<mapper url="file:///var/mappers/AuthorMapper.xml"/>

使⽤映射器接⼝实现类的完全限定类名，例如：

<mapper class="org.mybatis.builder.AuthorMapper"/>

将包内的映射器接⼝实现全部注册为映射器，例如：

<package name="org.mybatis.builder"/>

编写映射文件(XXXMapper.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="userMapper">
<!--集合foreach-->
    <select id="findByIds" resultType="user">
        <include refid="sql1"/>
        <where>
            <foreach collection="list" open="id in(" close=")" separator="," item="id">
                #{id}
            </foreach>
        </where>
    </select>
<!--查询所有-->
    <select id="findAll" resultType="com.hpe.bean.User">
        SELECT *FROM user
    </select>
    <!--parameterType指定传入的参数类型
    #（xxx）：相当于之前的？，里面的内容和实体类中的属性名对应
    -->
    <!--根据ID查询-->
    <select id="findById" parameterType="long" resultType="user">
        <include refid="sql1"/>
        WHERE id=#{id}
    <!--添加-->
    <insert id="add" parameterType="user">
        INSERT INTO user(username,password) VALUES(#{username},#{password})
    </insert>
    <!--删除
    #{任意字符串}方式引用传递的单个参数，如果传入的参数只有一个，
    大括号中的内容可以随意写，我们最好见名知意-->
    <delete id="delete" parameterType="long">
        DELETE FROM user WHERE id=#{id}
    </delete>
    <!--修改-->
    <update id="chg" parameterType="com.hpe.bean.User">
        UPDATE user SET username=#{username},password=#{password} WHERE id=#{id}
    </update>
    <!--根据用户名和密码查询(映射文件)-->
    <select id="findById" parameterType="long" resultType="com.hpe.bean.User">
        SELECT * FROM user WHERE id=#{id}
    </select>
</mapper>

映射配置+API（应用程序访问接口）实现增删改查。

//API
@Test
    public void testUserFindAll() {
        List<User> users = userMapper.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }

1.建数据库表
2.建实体类（访问修饰符必须用private，数据类型，对应的数据库中参数，set,get,tostring）(多表查询时，多对多（两个一对多）,访问修饰符private，创建一个List集合，代表当前sys user属于哪个角色sysroles)
3.创建接口(List findAll(); 在集合中查询所有信息)
int add(SysUser sysUser);（增加数据的方法）
SysRole findById(long l);（根据ID查询数据）
void del(Long l);(根据ID删除数据的方法)
4.配置表对应的映射⽂件

<!--resultMap：完成结果映射，表的字段到对象属性的映射，
在表的字段名和对象属性名不相同时通常会被用 到 id：
设置主键列的对应关系 result：设置普通列的对应关系 column：
表的字段名 property：对象的属性名 
这种映射关系了解即可，通常不用这种方式 -->
 <!--<resultMap id="orderMap" type="order"> 
 <id column="id" property="id" />
  <result column="ordertime" property="ordertime" />
  <result column="total" property="total" /> 
 <result column="uid" property="user.id" /> 
 <result column="username" property="user.username" />
  <result column="password" property="user.password" />
   </resultMap> -->
   <resultMap id="orderMap" type="order"> 
   <id column="id" property="id" /> 
   <result column="ordertime" property="ordertime" />
    <result column="total" property="total" />
 <!--association：用于建立一对一的关系 javaType：指定属性的类型 -->
  <association property="user" javaType="user">
   <id column="uid" property="id" />
    <result column="username" property="username" />
    <result column="password" property="password" /> 
   </association> 
   </resultMap>
   <!-- resultMap：用于指定要使用的resultMap --> 
   <select id="findAll" resultMap="orderMap"> 
   SELECTo.*, u.id uid, u.username username, u.password password 
   FROM`order` o, user u 
   WHEREo.uid=u.id;
    </select>

<!--添加一条用户信息并获得主键信息-->
    <insert id="add" parameterType="sysuser">
        <selectKey keyProperty="id" order="AFTER" keyColumn="id" resultType="Long">
            SELECT LAST_INSERT_ID()
        </selectKey>
        INSERT INTO sys_user(id,username,email,password,phoneNum) VALUES (#{id},#{username},#{email},#{password},#{phoneNum})
    </insert>

    <!--多表查询关联两表信息-->
    <resultMap id="sysUserMap" type="sysuser">
        <!--数据库列名，实体类名-->
        <id column="id" property="id" />
        <result column="username" property="username" />
        <result column="email" property="email" />
        <result column="password" property="password" />
        <result column="phoneNum" property="phoneNum" />
        <!--多表查询，一对多标签collection-->
        <collection property="sysRoles" ofType="sysrole">
            <!--数据库列名对应的实体类名-->
            <id column="rid" property="id" />
            <result column="roleName" property="roleName" />
            <result column="roleDesc" property="roleDesc" />
        </collection>
    </resultMap>
    <select id="findAll" resultMap="sysUserMap">
        SELECT
            u.*, r.id rid, r.roleName roleName, r.roleDesc roleDesc
        FROM
            sys_user u, sys_user_role ur, sys_role r
        WHERE
            u.id=ur.userId AND ur.roleId=r.id
    </select>

5.编写测试类

public class Mytest {
private OrderMapper orderMapper;
private SqlSession sqlSession;
@Before
 public void before() throws IOException { 
 InputStream resourceAsStream
 =Resources.getResourceAsStream("SqlMapConfig.xml"); 
 SqlSessionFactory factory = 
 new SqlSessionFactoryBuilder().build(resourceAsStream); 
 sqlSession = factory.openSession();
  userMapper = sqlSession.getMapper(UserMapper.class); 
  orderMapper = sqlSession.getMapper(OrderMapper.class);
   }
   	@After 
   	public void after() {
	sqlSession.close(); 
    
   }
   @Test 
   public void test1() { List<Order> orders = orderMapper.findAll(); for (Order order : orders) 
   { System.out.println(order); 
   }
    } 
    }

多表查询，
一对多
多对多（无法通过新增一列的方式来获取联系，新建一个第三个表）(双向的一对多)
查询所有SysUser表中的信息及对应的RoleUser表中的信息，不显示RoleUser表中没有的信息（以SysUser为主表）

typeHandlers标签
开发步骤： 1) 定义转换类继承类BaseTypeHandler;
2) 覆盖4个未实现的⽅法，其中setNonNullParameter为java程序设置数据到数据库的回调⽅法， getNullableResult为查询时 mysql的字符串类型转换成 java的Type类型的⽅法;
3) 在MyBatis核⼼配置⽂件中进⾏注册。

⾃定义类型转换器

//自定义类型转换器 
public class DateTypeHandler extends BaseTypeHandler<Date> {
 //将Java类型转换成数据库需要的类型 
 @Override 
 public void setNonNullParameter(PreparedStatement preparedStatement, int i, Date date, JdbcType jdbcType) throws SQLException { 
 long time = date.getTime(); 
 preparedStatement.setLong(i, time);
  }
  //将数据库类型转换成Java类型
   @Override 
   public Date getNullableResult(ResultSet resultSet, String s) throws SQLException {
    long l = resultSet.getLong(s);
     Date date = new Date(l); 
     return date; 
     }

配置⾃定义类型转换器

<!-- 配置自定义类型转换器 -->
<typeHandlers>
	<typeHandler handler="com.hpe.handler.DateTypeHandler" /> 
</typeHandlers>

@Test
    public void testSysUserFindAll() {
        List<SysUser> users = sysUserMapper.findAll();
        for (SysUser user : users) {
            System.out.println(user);
        }
    }

plugins标签
MyBatis可以使⽤第三⽅的插件来对功能进⾏扩展，分⻚助⼿PageHelper是将分⻚的复杂操作进⾏封装，使⽤简单的⽅式即可获得分⻚的相关数据。
开发步骤：

拷⻉相关jar包；
在核⼼配置⽂件配置PageHelper插件;
测试。

代理开发方式（低耦合，高扩展）
动态代理，jdk的动态代理 cglib动态代理，需要自己写接口
MyBatis通过动态代理的方式生成代理对象
代理对象的作用：和传统方式自己写的Dao的实现类作用是一样的
多表查询，一对多，（通过在表后面新增对应一列的方式来建立建立两表之间的联系）

MyBatis代理开发⽅式实现DAO层的开发，这种⽅式是⽬前企业的主流。 Mapper接⼝开发⽅法只需要程序员编写Mapper接⼝（相当于Dao 接⼝），由MyBatis框架根据接⼝定义创建接⼝的动态代理对象，代理对象的⽅法体同上边Dao接⼝实现类⽅法。

需要遵循的规范：

Mapper.xml⽂件中的namespace与mapper接⼝的全限定名相同；
Mapper接⼝⽅法名和Mapper.xml中定义的每个statement的id相同；
Mapper接⼝⽅法的输⼊参数类型和mapper.xml中定义的每个sql的parameterType的类型相同；
Mapper接⼝⽅法的返回值类型和mapper.xml中定义的每个sql的resultType的类型相同。
约定⼤于配置

动态SQL语句

<select id="findByCondition" resultType="user"> 
SELECT * from user 
	<where> 
		<if test="id!=null"> and id=#{id} 
		</if> 
		<if test="username!=null"> and username=#{username} 
		</if> 
		<if test="password!=null"> and password=#{password} 
		</if> 
	</where> 
</select>

对应的Mapper接⼝

List<User> findByCondition(User user);

测试⽅法

@Test 
public void testFindByCondition() { 
User user = new User();
 user.setId(1); 
 user.setUsername("tom"); 
 user.setPassword("123"); 
 List<User> users = userMapper.findByCondition(user); 
 users.forEach(u -> 
 System.out.println(u));
  }

通过实体类属性的不同取值，使⽤不同的SQL语句来进⾏查询。

动态SQL语句foreach
foreach⽤来循环执⾏sql的拼接操作，

<select id="findByIds" resultType="user">
 SELECT * from user 
 <where> 
	 <!--collection：代表要遍历的集合元素，注意编写时不要写#{} 
	 open：代表语句的开始部分 
	 close：代表结束部分
	  item：代表遍历集合的每个元素，生成的变量名
	   sperator：代表分隔符 --> 
 <foreach collection="list" open="id in (" close=")" separator="," item="id"> 
 #{id} 
 </foreach>
  </where>
  </select>

SQL⽚段抽取⽬的：
将重复的SQL提取出来，使⽤时⽤include引⽤即可，最终达到SQL重⽤的⽬的，减少代码冗余。

<sql id="selectAll">
 SELECT * FROM user 
 </sql>

Spring是什么
Spring是分层的 Java SE/EE应⽤full-stack轻量级开源框架，以IOC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：
⾯向切⾯编程）为内核。
提供了表现层SpringMVC和持久层Spring JDBCTemplate以及业务层事务管理等众多的企业级应⽤技术，还能整合开源世界众多著名的第三⽅框架和类库，逐渐成为使⽤最多的Java EE 企业应⽤开源框架。

Spring的优势

⽅便解耦，简化开发
通过Spring提供的IOC容器，可以将对象间的依赖关系交由Spring进⾏控制，避免硬编码所造成的过度耦合。
⽤⼾也不必再为单例模式类、属性⽂件解析等这些很底层的需求编写代码，可以更专注于上层的应⽤。
2)AOP 编程的⽀持
通过Spring的AOP功能，⽅便进⾏⾯向切⾯编程，许多不容易⽤传统OOP实现的功能可以通过AOP轻松实现。
声明式事务的⽀持
⽅便程序的测试

Spring程序开发步骤

新建⼯程导⼊相关Jar包；
编写接⼝和实现类；

//接口
 public interface UserDao { 
 void save();
  }

//实现类
 public class UserDaoImpl implements UserDao { 
 @Override 
 public void save() {
  System.out.println("save..."); 
	  } 
  }

编写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标签，创建相应类型的对象，并将创建的对象交给Spring容器进行管理 --> 
<bean id="userDao" class="com.hpe.dao.impl.UserDaoImpl">
</bean>
 </beans>

编写测试类进⾏测试。

public class MyTest {
 @Test
public void test() { 
//加载配置文件，创建应用上下文对象 
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
 //获取对象
  UserDao userDao = (UserDao) context.getBean("userDao"); 
  userDao.save(); 
	  } 
  }

Bean标签基本配置
作⽤：
通过配置将对象的创建交给Spring容器进⾏管理。
默认情况下它调⽤的是类中的⽆参构造函数，如果没有⽆参构造函数则不能创建成功。
id：Bean实例在Spring容器中的唯⼀标识；
class：Bean的全限定名称

Bean标签范围配置
singleton 默认值，单例的
prototype 多例的

当scope的取值为singleton时
Bean的实例化个数：1个
Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例

Bean的⽣命周期：
对象创建：当应用加载，创建容器时，对象就被创建了；
对象运行：只要容器在，对象一直活着；
对象销毁：当应用卸载，销毁容器时，对象就被销毁了。

当scope的取值为prototype时
Bean的实例化个数：多个
Bean的实例化时机：当调⽤getBean()⽅法时实例化Bean

Bean的⽣命周期：
对象创建：当使用对象时，创建新的对象实例；
对象运行：只要对象在使用中，就一直活着；
对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了。

Bean⽣命周期配置
init-method：指定类中的初始化方法名称
destroy-method：指定类中销毁方法名称

Bean实例化三种⽅式

使⽤⽆参构造⽅法实例化

<bean id="userDao" class="com.hpe.dao.impl.UserDaoImpl">

工厂静态方法实例化
工厂实例方法实例化

什么是依赖注入
依赖注入：Dependency Injection ，指容器负责创建和维护对象之间的依赖关系，而不是通过对象本⾝负责⾃⼰的创建和解决自己的依赖。
在当前类需要用到其他类的对象，由Spring为我们提供，我们只需要在配置中说明。
业务层和持久层的依赖关系，在使⽤ Spring 之后，就让 Spring 来维护了。
简单的说，就是坐等框架把持久层对象传⼊业务层，而不⽤我们自己去获取。

依赖注入方式
p名称空间注入
构造方法注入
set方法注入（重点）

在UserServiceImpl中添加set⽅法

public class UserServiceImpl implements UserService { 
private UserDao userDao; 
public void setUserDao(UserDao userDao) { 
this.userDao = userDao;
	 } 
 }

在Spring配置⽂件中配置

<bean id="userService" class="UserServiceImpl">
 <!-- set方法注入 -->
  <property name="userDao" ref="userDao">
  </property>
   </bean>

除了引⽤数据类型，普通数据类型，集合数据类型（List），集合数据类型（Properties）的注⼊，集合数据类型（Map<String, User>）也可以注入。

引⼊其他配置⽂件实际开发中，Spring的配置内容⾮常多，这就导致Spring配置很繁杂且体积很⼤，所以，可以将部分配置拆解到其他配置⽂件中，⽽在Spring主配置⽂件通过import标签进⾏加载。

<import resource="applicationContext-xxx.xml"/>

数据源（连接池）的作⽤
提⾼程序性能，事先在连接池中创建连接，使⽤连接资源时从数据源中获取，使⽤完毕后将连接归还到连接池。
常⻅的数据源：C3P0，DBCP，Druid等。

数据源的⼿动创建步骤

导⼊相关Jar包
新建数据源对象
1.工具类（手动new）
创建数据源,newComboPoolDateSource(自动解析，配置)
设置连接参数(set)
获取连接（get）
设置数据源的基本参数
使⽤数据源获取连接和归还资源

存在的问题

使⽤new的⽅式创建连接池对象，真正使⽤时耦合度太⼤；
连接池相关参数在代码中写死，硬编码，如果需要修改时，修改完需要重新编译，不利于后期维护。
解决方法
1. 使⽤Spring管理连接池对象的创建；
2. 在Spring配置⽂件中配置连接池相关参数。

@Test 
public void test1() throws PropertyVetoException, SQLException {
 	//创建数据源 
	ComboPooledDataSource dataSource = new ComboPooledDataSource();
	//设置连接参数 
	dataSource.setDriverClass("com.mysql.jdbc.Driver");
	dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
	dataSource.setUser("root"); dataSource.setPassword("123456"); 
	System.out.println(dataSource); 
	//获取连接 
	Connection connection = dataSource.getConnection(); 
	System.out.println(connection); 
	//关闭连接 
	connection.close(); 
}

2.pring配置数据源
DataSource有⽆参构造⽅法，⽽Spring默认就是通过⽆参构造⽅法实例化对象的；
DataSource要想使⽤需要通过set⽅法设置数据库连接信息，⽽Spring可以通过Set⽅法进⾏字符串注⼊
1.导⼊相关Jar包
2.在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标签，创建相应类型的对象，并将创建的对象交给Spring容器进行管理 --> 
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> 
<!-- set方法注入 --> <property name="driverClass" value="com.mysql.jdbc.Driver" /> 
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test" /> 
<property name="user" value="root" /> 
<property name="password" value="123456" /> 
</bean> 
</beans>

3.测试

@Test 
public void test2() throws SQLException { 
	//创建Spring容器 
	ApplicationContext context = new 
	ClassPathXmlApplicationContext("classpath:applicationContext.xml"); 
	//从Spring容器中获取数据源 DataSource dataSource = 
	(DataSource)context.getBean("dataSource"); 
	System.out.println(dataSource);
	//获取连接 
	Connection connection = dataSource.getConnection(); 
	System.out.println(connection); 
	//关闭连接 
	connection.close(); 
}

抽取JDBC配置⽂件
⼀般在项⽬中，我们把jdbc的配置单独放在⼀个properties配置⽂件当中，然后在Spring配置⽂件中引⼊这个配置。

编写jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver 
jdbc.url=jdbc:mysql://localhost:3306/test" 
jdbc.username=root 
jdbc.password=123456

在Spring配置⽂件中配置

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
xmlns:context="http://www.springframework.org/schema/context" 
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 
http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context.xsd"> 
<!-- 加载jdbc配置文件 使用context标签，一定要引用相关约束 --> 
<context:property-placeholder location="classpath:jdbc.properties" /> 
<!-- 通过bean标签，创建相应类型的对象，并将创建的对象交给Spring容器进行管理 --> 
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> 
<!-- set方法注入 --> <!-- 使用${key}的方式引入properties文件中的配置 --> 
<property name="driverClass" value="${jdbc.driver}" /> 
<property name="jdbcUrl" value="${jdbc.url}" /> 
<property name="user" value="${jdbc.username}" /> 
<property name="password" value="${jdbc.password}" /> 
</bean> 
</beans>

Spring整合MyBatis
整合思路
将Session⼯⼚交给Spring容器进⾏管理；
将事务交给Spring容器进⾏声明式事务控制

bixiaoya123

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
MyBatis（总结，超详细）

ssm传统JDBC操作的缺陷？1.代码存在大量重复性操作2.数据库连接创建，释放频繁造成代码不易维护，实际应用SQL变化的可能性较大，SQL变动需要改变Java代码3.查询操作时，需要手动将结果集中的数据封装到实体中，插叙操作时，需要手动将实体的数据设置到SQL语句的占位符位置ORMORM对象关系映射，数据库的表和实体类以及实体类的属性对应起来，让我们可以操作实体类实现操作数据库MyBatisMyBatis开发步骤1.新建项目，导入jar包2.创建user表3.编写user实体类4.
复制链接

扫一扫