Mybatis-1

最新推荐文章于 2023-09-09 16:01:07 发布

wb203

最新推荐文章于 2023-09-09 16:01:07 发布

阅读量242

点赞数

本文链接：https://blog.csdn.net/wb203/article/details/78455629

版权

1：MyBatis介绍

MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。 MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。

Mybatis通过xml或注解的方式将要执行的各种statement（statement、preparedStatement、CallableStatement）配置起来，并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射成java对象并返回。

2.使用JDBC编程问题总结

创建好数据库，在项目中导入所需要的jar后按照JDBC编码步骤进行编码，步骤：

1、加载数据库驱动

2、创建并获取数据库链接

3、创建jdbc statement对象

4、设置sql语句

5、设置sql语句中的参数(使用preparedStatement)

6、通过statement执行sql并获取结果

7、对sql执行结果进行解析处理

8、释放资源(resultSet、preparedstatement、connection)

示例代码：

public static void main(String[] args) {
		Connection connection = null;
		 preparedStatement = null;
		ResultSet resultSet = null;
		
		try {
			//加载数据库驱动
			Class.forName("com.mysql.jdbc.Driver");
			
			//通过驱动管理类获取数据库链接
			connection =  DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "root");
			//定义sql语句 ?表示占位符
			String sql = "select * from user where username = ?";
			//获取预处理statement
			preparedStatement = connection.prepareStatement(sql);
			//设置参数，第一个参数为sql语句中参数的序号（从1开始），第二个参数为设置的参数值
			preparedStatement.setString(1, "王五");
			//向数据库发出sql执行查询，查询出结果集
			resultSet =  preparedStatement.executeQuery();
			//遍历查询结果集
			while(resultSet.next()){
				System.out.println(resultSet.getString("id")+"  "+resultSet.getString("username"));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			//释放资源
			if(resultSet!=null){
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			if(preparedStatement!=null){
				try {
					preparedStatement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			if(connection!=null){
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}

	}

上边使用jdbc的原始方法（未经封装）实现了查询数据库表记录的操作。

使用JDBC问题总结如下：

1、数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。

2、Sql语句在代码中硬编码，造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。

3、使用preparedStatement向占有位符号传参数存在硬编码，因为sql语句的where条件不一定，可能多也可能少，修改sql还要修改代码，系统不易维护。

4、对结果集解析存在硬编码（查询列名），sql变化导致解析代码变化，系统不易维护，如果能将数据库记录封装成pojo对象解析比较方便。

Mybatis架构

Mybatis入门--实现增删查改：

1.创建java工程，导入所需要的jar

2.创建pojo类，提供getter和setter

package cn.itheima.pojo;

import java.util.Date;
import java.util.List;

public class User {
	private int id;
	private String username;// 用户姓名
	private String sex;// 性别
	private Date birthday;// 生日
	private String address;// 地址
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public Date getBirthday() {
		return birthday;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", username=" + username + ", sex=" + sex
				+ ", birthday=" + birthday + ", address=" + address + "]";
	}

}

3.在classpath下创建log4j.properties（放在创建名为config的Source Folder下）

# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

4.在classpath下创建 User.xml（放在创建名为config的Source Folder下）

<?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">
<!-- namespace:命名空间,做sql隔离 -->
<mapper namespace="test">

	<!-- 
	id:sql语句唯一标识
	parameterType:指定传入参数类型
	resultType:返回结果集类型
	#{}占位符:起到占位作用,如果传入的是基本类型(string,long,double,int,boolean,float等),那么#{}中的变量名称可以随意写.
	 -->
	<select id="findUserById" parameterType="java.lang.Integer" resultType="cn.itheima.pojo.User">
		select * from user where id=#{id}
	</select>
	
	<!-- 
	如果返回结果为集合,可以调用selectList方法,这个方法返回的结果就是一个集合,所以映射文件中应该配置成集合泛型的类型
	${}拼接符:字符串原样拼接,如果传入的参数是基本类型(string,long,double,int,boolean,float等),那么${}中的变量名称必须是value
	注意:拼接符有sql注入的风险,所以慎重使用
	 -->
	<select id="findUserByUserName" parameterType="java.lang.String" resultType="cn.itheima.pojo.User">
		select * from user where username like '%${value}%'
	</select>
	
	<!-- 
	#{}:如果传入的是pojo类型,那么#{}中的变量名称必须是pojo中对应的属性.属性.属性.....
	如果要返回数据库自增主键:可以使用select LAST_INSERT_ID()
	 -->
	<insert id="insertUser" parameterType="cn.itheima.pojo.User" >
		<!-- 执行 select LAST_INSERT_ID()数据库函数,返回自增的主键
		keyProperty:将返回的主键放入传入参数的Id中保存.
		order:当前函数相对于insert语句的执行顺序,在insert前执行是before,在insert后执行是AFTER
		resultType:id的类型,也就是keyproperties中属性的类型
		-->
		<selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">
			select LAST_INSERT_ID()
		</selectKey>
		insert into user (username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
	</insert>
	
	<delete id="delUserById" parameterType="int">
		delete from user where id=#{id}
	</delete>
	
	<update id="updateUserById" parameterType="cn.itheima.pojo.User">
		update user set username=#{username} where id=#{id}
	</update>
</mapper>

4.1 #{}和${}的不同

#{}表示一个占位符号，通过#{}可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换，#{}可以有效防止sql注入。 #{}可以接收简单类型值或pojo属性值。如果parameterType传输单个简单类型值，#{}括号中可以是value或其它名称。

${}表示拼接sql串，通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换， ${}可以接收简单类型值或pojo属性值，如果parameterType传输单个简单类型值，${}括号中只能是value。

4.2 arameterType和resultType

parameterType：指定输入参数类型，mybatis通过ognl从输入对象中获取参数值拼接在sql中。

resultType：指定输出结果类型，mybatis将sql查询结果的一行记录数据映射为resultType指定类型的对象。

4.3 selectOne和selectList

selectOne：查询一条记录，如果使用selectOne查询多条记录则抛出异常：

org.apache.ibatis.exceptions.TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 3

at org.apache.ibatis.session.defaults.DefaultSqlSession.selectOne(DefaultSqlSession.java:70)

selectList：可以查询一条或多条记录。

4.4 添加 selectKey实现将主键返回

keyProperty:返回的主键存储在pojo中的哪个属性

order：selectKey的执行顺序，是相对与insert语句来说，由于mysql的自增原理执行完insert语句之后才将主键生成，所以这里selectKey的执行顺序为after

resultType:返回的主键是什么类型

LAST_INSERT_ID():是mysql的函数，返回auto_increment自增列新记录id值。

4.5 Mysql使用uuid实现主键

需要增加通过select uuid()得到uuid值

select uuid()

</selectKey>

insert into user(id,username,birthday,sex,address)

values(#{id},#{username},#{birthday},#{sex},#{address})

</insert>

注意这里使用的order是“BEFORE”

5.在classpath下创建db.properties（放在创建名为config的Source Folder下）

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

6.在classpath下创建SqlMapConfig.xml（放在创建名为config的Source Folder下）

<?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="db.properties"></properties>

	<!-- 和spring整合后 environments配置将废除-->
	<environments default="development">
		<environment id="development">
		<!-- 使用jdbc事务管理-->
		<transactionManager type="JDBC" />
		<!-- 数据库连接池-->
		<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="User.xml"/>
	</mappers>
</configuration>

7 .编写测试类

public class UserTest {
	
	@Test
	public void testFindUserById() throws Exception{
		String resource="SqlMapConfig.xml";
		//通过流将核心配置文件读取进来
		InputStream inputStream=Resources.getResourceAsStream(resource);
		//通过核心配置文件输入流来创建会话工厂
		SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputStream);
		//通过工厂创建会话
		SqlSession openSession = factory.openSession();
		//调用查询方法
		//第一个参数：新调用的SQL语句=namespace+.+sql的ID
		//第二个参数：传入的参数
		User user = openSession.selectOne("test.findUserById",1);
		System.out.println(user);
		openSession.close();
	}
	
	
	
	@Test
	public void testFindUserByName() throws Exception{
		String resource="SqlMapConfig.xml";
		//通过流将核心文件读取进来
		InputStream inputStream=Resources.getResourceAsStream(resource);
		//通过核心配置文件输入流来创建会话工厂
		SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputStream);
		//通过工厂创建会话
		SqlSession openSession = factory.openSession();
		//调用查询方法
		List<Object> list = openSession.selectList("test.findUserByName","王");
		System.out.println(list);
	}
	
	
	
	@Test
	public void testInsertUser() throws Exception{
		String resource="SqlMapConfig.xml";
		//通过流将核心文件读取进来
		InputStream inputStream=Resources.getResourceAsStream(resource);
		//通过核心配置文件输入流来创建会话工厂
		SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputStream);
		//通过工厂创建会话
		SqlSession openSession = factory.openSession();
		
		//调用查询方法
		User user=new User();
		user.setUsername("赵四");
		user.setBirthday(new Date());
		user.setSex("1");
		user.setAddress("北京昌平");
		openSession.insert("test.insertUser",user);
		//提交事务(mybatis会自动开启事务，但是它不知道何时提交事务。所以需要手动提交事务)
		openSession.commit();
	}
	
	
	
	@Test
	public void testDelUserById() throws Exception{
		String resource="SqlMapConfig.xml";
		//通过流将核心文件读取进来
		InputStream inputStream=Resources.getResourceAsStream(resource);
		//通过核心配置文件输入流来创建会话工厂
		SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputStream);
		//通过工厂创建会话
		SqlSession openSession = factory.openSession();
		
		openSession.delete("test.delUserById",28);
		//提交事务(mybatis会自动开启事务，但是它不知道何时提交事务。所以需要手动提交事务)
		openSession.commit();
	}
	
	
	@Test
	public void testUpdateUserById() throws Exception{
		String resource="SqlMapConfig.xml";
		//通过流将核心文件读取进来
		InputStream inputStream=Resources.getResourceAsStream(resource);
		//通过核心配置文件输入流来创建会话工厂
		SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputStream);
		//通过工厂创建会话
		SqlSession openSession = factory.openSession();
		
		User user=new User();
		user.setId(27);
		user.setUsername("王麻子");
		openSession.update("test.updateUserById",user);
		//提交事务(mybatis会自动开启事务，但是它不知道何时提交事务。所以需要手动提交事务)
		openSession.commit();
	}
}

8.小结：

8.1 Mybatis解决JDBC编程的问题

1、数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。

解决：在SqlMapConfig.xml中配置数据链接池，使用连接池管理数据库链接。

2、 Sql语句写在代码中造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。

解决：将Sql语句配置在XXXXmapper.xml文件中与java代码分离。

3、向sql语句传参数麻烦，因为sql语句的where条件不一定，可能多也可能少，占位符需要和参数一一对应。

解决：Mybatis自动将java对象映射至sql语句，通过statement中的parameterType定义输入参数的类型。

4、对结果集解析麻烦，sql变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成pojo对象解析比较方便。

解决：Mybatis自动将sql执行结果映射至java对象，通过statement中的resultType定义输出结果的类型。

8.2 Mybatis与hibernate不同

Mybatis和hibernate不同，它不完全是一个ORM框架，因为MyBatis需要程序员自己编写Sql语句，不过mybatis可以通过XML或

注解方式灵活配置要运行的sql语句，并将java对象和sql语句映射生成最终执行的sql，最后将sql执行的结果再映射生成java对象。

Mybatis学习门槛低，简单易学，程序员直接编写原生态sql，可严格控制sql执行性能，灵活度高，非常适合对关系数据模型

要求不高的软件开发，例如互联网软件、企业运营类软件等，因为这类软件需求变化频繁，一但需求变化要求成果输出迅速。

但是灵活的前提是mybatis无法做到数据库无关性，如果需要实现支持多种数据库的软件则需要自定义多套sql映射文件，工作量大。

Hibernate对象/关系映射能力强，数据库无关性好，对于关系模型要求高的软件（例如需求固定的定制化软件）如果用hibernate

开发可以节省很多代码，提高效率。但是Hibernate的学习门槛高，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间

如何权衡，以及怎样用好Hibernate需要具有很强的经验和能力才行。

总之，按照用户的需求在有限的资源环境下只要能做出维护性、扩展性良好的软件架构都是好架构，所以框架只有适合才是最好。

使用Mybatis开发Dao

需求：

将下边的功能实现Dao：

根据用户id查询一个用户信息

根据用户名称模糊查询用户信息列表

添加用户信息

使用Mybatis开发Dao，通常有两个方法，即原始Dao开发方法和Mapper接口开发方法。

SqlSession使用范围

SqlSession 中封装了对数据库的操作，如：查询、插入、更新、删除等。

通过SqlSessionFactory创建SqlSession，而SqlSessionFactory是通过SqlSessionFactoryBuilder进行创建。

SqlSessionFactoryBuilder

SqlSessionFactoryBuilder用于创建SqlSessionFacoty，SqlSessionFacoty一旦创建完成就不需要SqlSessionFactoryBuilder了，

因为SqlSession是通过SqlSessionFactory生产，所以可以将SqlSessionFactoryBuilder当成一个工具类使用，最佳使用范围是方法范围

即方法体内局部变量。

SqlSessionFactory

SqlSessionFactory是一个接口，接口中定义了openSession的不同重载方法，SqlSessionFactory的最佳使用范围是整个应用运行期间，

一旦创建后可以重复使用，通常以单例模式管理SqlSessionFactory。

SqlSession

SqlSession是一个面向用户的接口，sqlSession中定义了数据库操作方法。每个线程都应该有它自己的SqlSession实例。SqlSession

的实例不能共享使用，它也是线程不安全的。因此最佳的范围是请求或方法范围。绝对不能将SqlSession实例的引用放在一个类的静态

字段或实例字段中。打开一个 SqlSession；使用完毕就要关闭它。通常把这个关闭操作放到finally块中以确保每次都能执行关闭。如下：

SqlSession session = sqlSessionFactory.openSession();
	try {
 		 // do work
	} finally {
  		session.close();
	}

1.原始Dao开发方法

原始Dao开发方法需要程序员编写Dao接口和Dao实现类。

1.0 pojo类(User)、User.xml、db.properties、log4j.properties、SqlMapConfig.xml不变

1.1 编写Dao接口

public interface UserDao {

	public User findUserById(Integer id);
	
	public List<User> findUserByUserName(String userName);
	
	public void insertUser(User user);
}

1.2 编写Dao实现类

public class UserDaoImpl implements UserDao {
	
	private SqlSessionFactory sqlSessionFactory;
	private List<User> list;
	private Object user;
	
	//通过构造方法注入
	public UserDaoImpl(SqlSessionFactory sqlSessionFactory) {
		this.sqlSessionFactory = sqlSessionFactory;
	}

	@Override
	public User findUserById(Integer id) {
		//sqlSession是线程不安全的，所以它的最佳使用范围在方法体内
		SqlSession sqlsession= sqlSessionFactory.openSession();
		try {
			//通过sqlsession调用selectOne方法获取一条结果集
			//参数1：指定定义的statement的id,参数2：指定向statement中传递的参数
			user = sqlSession.selectOne("test.findUserById", 1);
						
		} finally{
			sqlSession.close();
		}
		return user;
	}

	@Override
	public List<User> findUserByUserName(String userName) {
		SqlSession sqlSession = sqlSessionFactory.openSession();
		try {
			list = sqlSession.selectList("test.findUserByUserName", userName);
		} finally{
			sqlSession.close();
		}

		return list;
	}

	@Override
	public void insertUser(User user) {
		SqlSession sqlSession = sqlSessionFactory.openSession();
		try {
			sqlSession.insert("test.insertUser", user);
			sqlSession.commit();
		} finally{
			sqlSession.close();
		}
		
	}
	
}

1.3 编写测试类

public class UserDaoTest {
	
	private SqlSessionFactory factory;
	
	//作用：在测试方法前执行这个方法
	@Before
	public void setUp() throws Exception{
		String resource="SqlMapConfig.xml";
		//通过流将核心文件读取进来
		InputStream inputStream=Resources.getResourceAsStream(resource);
		//通过核心配置文件输入流来创建会话工厂
		factory=new SqlSessionFactoryBuilder().build(inputStream);
	}
	
	@Test
	public void testFindUserById() throws Exception{
		//将初始化好的工厂注入到实现类中
		UserDao userDao=new UserDaoImpl(factory);
		
		User user = userDao.findUserById(1);
		System.out.println(user);
	}
	
	@Test
	public void testFindUserByUserName() throws Exception{
		UserDao userDao=new UserDaoImpl(factory);
		List<User> list = userDao.findUserByUserName("王");
		System.out.println(list);
	}
	
	@Test
	public void testInsertUser() throws Exception{
		UserDao userDao=new UserDaoImpl(factory);
		User user=new User();
		user.setUsername("赵四");
		user.setBirthday(new Date());
		user.setSex("1");
		user.setAddress("北京昌平");
		userDao.insertUser(user);
		
	}
}

1.4 原始Dao开发中存在以下问题：

1）Dao方法体存在重复代码：通过SqlSessionFactory创建SqlSession，调用SqlSession的数据库操作方法。

2）调用sqlSession的数据库操作方法需要指定statement的id，这里存在硬编码，不利于开发维护。

2.使用Mapper动态代理方式开发Dao

2.0 开发规范

Mapper接口开发方法只需要程序员编写Mapper接口（相当于Dao接口），由Mybatis框架根据接口定义创建接口的动态代理对象，

代理对象的方法体同上边Dao接口实现类方法。

Mapper接口开发需要遵循以下规范：

1）Mapper.xml文件中的namespace与mapper接口的类路径相同。

2）Mapper接口方法名和Mapper.xml中定义的每个statement的id相同

3）Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql的parameterType的类型相同

4）Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同

2.1 编写Mapper接口

public interface UserMapper {

	public User findUserById(Integer id);
	
	//动态代理形式中，如果返回结果集合List，那么mybatis会在生成实现类的时候会自动调用selectList方法
	public List<User> findUserByUserName(String userName);
	
	public void insertUser(User user);
	
}

2.2 编写Mapper.xml映射文件UserMapper.xml(要和Mapper在同一路径)

<?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接口代理实现编写规则:
	1. 映射文件中namespace要等于接口的全路径名称
	2. 映射文件中sql语句id要等于接口的方法名称
	3. 映射文件中传入参数类型要等于接口方法的传入参数类型
	4. 映射文件中返回结果集类型要等于接口方法的返回值类型
 -->
<mapper namespace="cn.itheima.mapper.UserMapper">

	<!-- 
	id:sql语句唯一标识
	parameterType:指定传入参数类型
	resultType:返回结果集类型
	#{}占位符:起到占位作用,如果传入的是基本类型(string,long,double,int,boolean,float等),那么#{}中的变量名称可以随意写.
	 -->
	<select id="findUserById" parameterType="int" resultType="cn.itheima.pojo.User">
		select * from user where id=#{id}
	</select>
	
	<!-- 
	如果返回结果为集合,可以调用selectList方法,这个方法返回的结果就是一个集合,所以映射文件中应该配置成集合泛型的类型
	${}拼接符:字符串原样拼接,如果传入的参数是基本类型(string,long,double,int,boolean,float等),那么${}中的变量名称必须是value
	注意:拼接符有sql注入的风险,所以慎重使用
	 -->
	<select id="findUserByUserName" parameterType="string" resultType="user">
		select * from user where username like '%${value}%'
	</select>
	
	<!-- 
	#{}:如果传入的是pojo类型,那么#{}中的变量名称必须是pojo中对应的属性.属性.属性.....
	如果要返回数据库自增主键:可以使用select LAST_INSERT_ID()
	 -->
	<insert id="insertUser" parameterType="cn.itheima.pojo.User" >
		<!-- 执行 select LAST_INSERT_ID()数据库函数,返回自增的主键
		keyProperty:将返回的主键放入传入参数的Id中保存.
		order:当前函数相对于insert语句的执行顺序,在insert前执行是before,在insert后执行是AFTER
		resultType:id的类型,也就是keyproperties中属性的类型
		-->
		<selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">
			select LAST_INSERT_ID()
		</selectKey>
		insert into user (username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
	</insert>
	
</mapper>

2.3 在SqlMapConfig.xml这种引入对应的UserMapper.xml

蓝色部分是起别名，起了别名之后，在UserMapper.xml中类型就可以用别名，UserMapper蓝色部分就是用了起的别名。

当然，Mybatis也有默认别名，例如UserMapper.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="db.properties"></properties>
	
	<typeAliases> 
		<!-- 定义单个pojo类别名
		type:类的全路劲名称
		alias:别名
		 -->
<!-- 		<typeAlias type="cn.itheima.pojo.User" alias="user"/> -->
		
		<!-- 使用包扫描的方式批量定义别名 
		定以后别名等于类名,不区分大小写,但是建议按照java命名规则来,首字母小写,以后每个单词的首字母大写
		-->
		<package name="cn.itheima.pojo"/>
	</typeAliases>

	<!-- 和spring整合后 environments配置将废除-->
	<environments default="development">
		<environment id="development">
		<!-- 使用jdbc事务管理-->
		<transactionManager type="JDBC" />
		<!-- 数据库连接池-->
		<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="User.xml"/> -->

		<!-- 
		使用class属性引入接口的全路径名称:
		使用规则:
			1. 接口的名称和映射文件名称除扩展名外要完全相同
			2. 接口和映射文件要放在同一个目录下
		 -->
<!-- 		<mapper class="cn.itheima.mapper.UserMapper"/> -->
		
		<!-- 使用包扫描的方式批量引入Mapper接口 
				使用规则:
				1. 接口的名称和映射文件名称除扩展名外要完全相同
				2. 接口和映射文件要放在同一个目录下
		-->
		<package name="cn.itheima.mapper"/>
	</mappers>
</configuration>

2.4 编写测试类

public class UserMapperTest {

	private SqlSessionFactory factory;
	
	//作用：在测试方法前执行这个方法
	@Before
	public void setUp() throws Exception{
		String resource="SqlMapConfig.xml";
		//通过流将核心文件读取进来
		InputStream inputStream=Resources.getResourceAsStream(resource);
		//通过核心配置文件输入流来创建会话工厂
		factory=new SqlSessionFactoryBuilder().build(inputStream);
	}
	
	@Test
	public void testFindUserById() throws Exception{
		SqlSession openSession = factory.openSession();
		//通过getMapper方法实例化接口
		UserMapper mapper = openSession.getMapper(UserMapper.class);
		User user = mapper.findUserById(1);
		System.out.println(user);
	}
	
	
	@Test
	public void testFindUserByUserName() throws Exception{
		SqlSession openSession = factory.openSession();
		//通过getMapper方法实例化接口
		UserMapper mapper = openSession.getMapper(UserMapper.class);
		List<User> list = mapper.findUserByUserName("王");
		System.out.println(list);
	}
	
	
	@Test
	public void testInsertUser() throws Exception{
		SqlSession openSession = factory.openSession();
		//通过getMapper方法实例化接口
		UserMapper mapper = openSession.getMapper(UserMapper.class);
		User user=new User();
		user.setUsername("老王");
		user.setSex("1");
		user.setBirthday(new Date());
		user.setAddress("北京昌平");
		mapper.insertUser(user);
		openSession.commit();
	}
	
}

2.5 小结：

selectOne和selectList

动态代理对象调用sqlSession.selectOne()和sqlSession.selectList()是根据mapper接口方法的返回值决定，如果返

回list则调用selectList方法，如果返回单个对象则调用selectOne方法。

namespace

mybatis官方推荐使用mapper代理方法开发mapper接口，程序员不用编写mapper接口实现类，使用mapper代理方

法时，输入参数可以使用pojo包装对象或map对象，保证dao的通用性。

SqlMapConfig.xml配置文件说明

SqlMapConfig.xml中配置的内容和顺序如下：

properties（属性）

settings（全局配置参数）

typeAliases（类型别名）

typeHandlers（类型处理器）

objectFactory（对象工厂）

plugins（插件）

environments（环境集合属性对象）

environment（环境子属性对象）

transactionManager（事务管理）

dataSource（数据源）

mappers（映射器）

typeAliases（类型别名）

别名	映射的类型
_byte	byte
_long	long
_short	short
_int	int
_integer	int
_double	double
_float	float
_boolean	boolean
string	String
byte	Byte
long	Long
short	Short
int	Integer
integer	Integer
double	Double
float	Float
boolean	Boolean
date	Date
decimal	BigDecimal
bigdecimal	BigDecimal
map	Map

结构：

总结：

pojo:不按mvc分层,只是java bean有一些属性,还有get set方法。

domain:不按mvc分层,只是java bean有一些属性,还有get set方法。
po:用在持久层,还可以再增加或者修改的时候,从页面直接传入action中,它里面的java bean 类名等于表名,
属性名等于表的字段名,还有对应的get set方法
vo: view object表现层对象,主要用于在高级查询中从页面接收传过来的各种参数.好处是扩展性强
bo: 用在servie层,现在企业基本不用.
这些po,vo, bo,pojo可以用在各种层面吗？
可以,也就是po用在表现层,vo用在持久层不报错,因为都是普通的java bean没有语法错误.
但是在企业最好不要混着用,因为这些都是设计的原则,混着用比较乱.不利于代码维护.

1. mybatis是一个持久层框架, 作用是跟数据库交互完成增删改查
2.原生Dao实现(需要接口和实现类)
4.动态代理方式(只需要接口)
mapper接口代理实现编写规则:
1) 映射文件中namespace要等于接口的全路径名称
2) 映射文件中sql语句id要等于接口的方法名称
3) 映射文件中传入参数类型要等于接口方法的传入参数类型
4) 映射文件中返回结果集类型要等于接口方法的返回值类型
5. #{}占位符:占位
如果传入的是基本类型,那么#{}中的变量名称可以随意写
如果传入的参数是pojo类型,那么#{}中的变量名称必须是pojo中的属性.属性.属性...
6. ${}拼接符:字符串原样拼接
如果传入的是基本类型,那么${}中的变量名必须是value
如果传入的参数是pojo类型,那么${}中的变量名称必须是pojo中的属性.属性.属性...
注意:使用拼接符有可能造成sql注入,在页面输入的时候可以加入校验,不可输入sql关键字,不可输入空格
7. 映射文件:
1)传入参数类型通过parameterType属性指定
2)返回结果集类型通过resultType属性指定
8. hibernate和mybatis区别:
hibernate:它是一个标准的orm框架,比较重量级,学习成本高.
优点:高度封装,使用起来不用写sql,开发的时候,会减低开发周期.
缺点:sql语句无法优化
应用场景:oa(办公自动化系统), erp(企业的流程系统)等,还有一些政府项目,
总的来说,在用于量不大,并发量小的时候使用.
mybatis:它不是一个orm框架, 它是对jdbc的轻量级封装, 学习成本低,比较简单
有点:学习成本低, sql语句可以优化, 执行效率高,速度快
缺点:编码量较大,会拖慢开发周期
应用场景: 互联网项目,比如电商,P2p等
总的来说是用户量较大,并发高的项目.

wb203

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mybatis-1

1：MyBatis介绍MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。 MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL本身，而不需要花费精力去处理例如注册驱动...
复制链接

扫一扫