MyBatis（总结，超详细）
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 id="sql1">
SELECT * FROM user
sql>
编写核心配置文件(SqlMapConfig.xml)
<configuration>
<properties resource="jdbc.properties"/>
<typeAliases>
<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>
<environments default="dev">
<environment id="dev">
<transactionManager type="JDBC">transactionManager>
<dataSource type="POOLED">
<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)
<mapper namespace="userMapper">
<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>
<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="orderMap" type="order">
<id column="id" property="id" />
<result column="ordertime" property="ordertime" />
<result column="total" property="total" />
<association property="user" javaType="user">
<id column="uid" property="id" />
<result column="username" property="username" />
<result column="password" property="password" />
association>
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 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>
<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核⼼配置⽂件；
<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="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">
<property name="userDao" ref="userDao">
property>
bean>
除了引⽤数据类型，普通数据类型，集合数据类型 （List），集合数据类型（Properties）的注⼊，集合数据类型（Map
引⼊其他配置⽂件 实际开发中，Spring的配置内容⾮常多，这就导致Spring配置很繁杂且体积很⼤，所以，可以将部分配 置拆解到其他配置⽂件中，⽽在Spring主配置⽂件通过import标签进⾏加载。
<import resource="applicationContext-xxx.xml"/>
数据源（连接池）的作⽤
提⾼程序性能，事先在连接池中创建连接，使⽤连接资源时从数据源中获取，使⽤完毕后将连接归还到 连接池。
常⻅的数据源：C3P0，DBCP，Druid等。
数据源的⼿动创建步骤
- 导⼊相关Jar包
- 新建数据源对象
1.工具类（手动new）
创建数据源,newComboPoolDateSource(自动解析，配置)
设置连接参数(set)
获取连接（get） - 设置数据源的基本参数
- 使⽤数据源获取连接和归还资源
存在的问题
- 使⽤new的⽅式创建连接池对象，真正使⽤时耦合度太⼤；
- 连接池相关参数在代码中写死，硬编码，如果需要修改时，修改完需要重新编译，不利于后期维护。
解决方法- 使⽤Spring管理连接池对象的创建；
- 在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配置⽂件中配置
<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="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<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配置⽂件中配置
<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">
<context:property-placeholder location="classpath:jdbc.properties" />
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<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容器进⾏声明式事务控制