一个传统的JDBC程序如下:
public static void main(String[] args) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
try {
//1. 加载驱动
Class.forName("com.mysql.jdbc.Driver");
//2. 获得链接
connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/database", "username", "password");
//3. 创建statement
String sql = "select * from user where id = ? and username = ?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, "王五");
// 4. 执行statement
resultSet = preparedStatement.executeQuery();
// 5. 遍历结果
while (resultSet.next()) {
System.out.println(resultSet.getString("id") + "" + resultSet.getString("username"));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 6. 释放资源
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,存在以下问题:
在数据库中创建表users
并添加数据
DROP TABLE IF EXISTS `users`;
CREATE TABLE `users` (
`id` int(11) NOT NULL auto_increment,
`username` varchar(32) NOT NULL COMMENT '用户名称',
`birthday` datetime default NULL COMMENT '生日',
`sex` char(1) default NULL COMMENT '性别',
`address` varchar(256) default NULL COMMENT '地址',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
insert into `users`(`id`,`username`,`birthday`,`sex`,`address`) values (41,'老王','2018-02-27 17:47:08','男','北京'),(43,'小二王','2018-03-04 11:34:34','女','北京金燕龙'),(45,'传智播客','2018-03-04 12:04:06','男','北京金燕龙'),(46,'老王','2018-03-07 17:37:26','男','北京'),(48,'小马宝莉','2018-03-08 11:44:00','女','北京修正');
创建Maven项目并在pom.xml
中引入依赖坐标如下
<dependencies>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.4.5version>
dependency>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.10version>
<scope>testscope>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.6version>
<scope>runtimescope>
dependency>
<dependency>
<groupId>log4jgroupId>
<artifactId>log4jartifactId>
<version>1.2.12version>
dependency>
dependencies>
在resources
目录下创建log4j
的配置文件log4j.properties
如下:
# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE debug info warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE
# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n
# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n
创建与数据库表对应的pojo类型User
,注意入门程序中我们要求pojo类User
属性名和数据库表users
的字段名严格相同
package cn.maoritian.domain;
public class User implements Serializable {
// 属性名和数据库表字段名严格相同
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
// 各属性的 set 和 get 方法
public Integer getId() {return id; }
public void setId(Integer id) {this.id = id; }
public String getUsername() {return username; }
public void setUsername(String username) {this.username = username; }
public Date getBirthday() {return birthday; }
public void setBirthday(Date birthday) {this.birthday = birthday; }
public String getSex() {return sex; }
public void setSex(String sex) {this.sex = sex; }
public String getAddress() {return address; }
public void setAddress(String address) {this.address = address; }
// toString()方法
@Override
public String toString() {
return "User{" + "id=" + id + ", username='" + username + '\'' + ", birthday=" + birthday + ", sex='" + sex + '\'' + ", address='" + address + '\'' + '}';
}
}
编写持久层接口IUserDao
package cn.maoritian.dao;
// 持久层接口
public interface IUserDao {
// 返回所有用户列表
List<User> findAll();
}
在resource
目录下创建Mybatis配置文件SqlMapConfig.xml
如下
<configuration>
<environments default="mysql">
<environment id="mysql">
<transactionManager type="JDBC">transactionManager>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mydatabase"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
dataSource>
environment>
environments>
configuration>
实现持久层接口
我们把sql语句写进xml文件中,让Mybatis框架通过反射给我们提供持久层接口的实现类.
配置持久层接口的sql语句
我们在resource
目录下创建cn/maoritian/dao/IUserDao.xml
文件.xml文件的路径和文件名与java代码中的包路径和类名严格相同.
使用
标签配置实现的接口,标签配置接口中的查询方法
<mapper namespace="cn.maoritian.dao.IUserDao">
<select id="findAll" resultType="cn.maoritian.domain.User">
select * from user
select>
mapper>
在Mybatis配置文件SqlMapConfig.xml
中使用mapper
标签指定sql语句配置文件.在SqlMapConfig.xml
的configure
节点下添加如下配置.
<mappers>
<mapper resource="cn/maoritian/dao/IUserDao.xml"/>
mappers>
我们已经完成了一个Mybatis入门项目,写出测试代码如下:
package cn.maoritian.dao.impl;
public class MybatisTest {
public static void main(String[] args) throws Exception {
// 1.读取配置文件
InputStream config = Resources.getResourceAsStream("SqlMapConfig.xml");
// 2.创建SqlSessionFactory工厂
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(config);
// 3.使用工厂生产SqlSession对象
SqlSession session = factory.openSession();
// 4.使用SqlSession创建Dao接口的代理对象
IUserDao userDao = session.getMapper(IUserDao.class);
// 5.使用代理对象执行方法
List<User> users = userDao.findAll();
for (User user : users) {
System.out.println(user);
}
// 6.释放资源
session.close();
config.close();
}
}
运行测试程序,输出如下,说明代码执行成功
User{id=41, username='老王', birthday=Tue Feb 27 17:47:08 CST 2018, sex='男', address='北京'}
User{id=42, username='小二王', birthday=Fri Mar 02 15:09:37 CST 2018, sex='女', address='北京金燕龙'}
User{id=45, username='传智播客', birthday=Sun Mar 04 12:04:06 CST 2018, sex='男', address='北京金燕龙'}
User{id=46, username='老王', birthday=Wed Mar 07 17:37:26 CST 2018, sex='男', address='北京'}
User{id=48, username='小马宝莉', birthday=Thu Mar 08 11:44:00 CST 2018, sex='女', address='北京修正'}
在这个案例中,我们将sql语句写在持久层的注解中.数据库结构和测试代码均与上个案例相同.我们只要修改持久层接口IUserDao
和Mybatis配置文件
在持久层接口的方法定义上加以@Select
注解,其value
属性为该方法要执行的sql语句
package cn.maoritian.dao;
// 持久层接口
public interface IUserDao {
// 返回所有用户列表
@Select("select * from users")
List<User> findAll();
}
在Mybatis配置文件SqlMapConfig.xml
中配置mapper
如下
<mappers>
<mapper class="cn.maoritian.dao.IUserDao"/>
mappers>
运行测试程序,输出如下,说明代码执行成功
User{id=41, username='老王', birthday=Tue Feb 27 17:47:08 CST 2018, sex='男', address='北京'}
User{id=42, username='小二王', birthday=Fri Mar 02 15:09:37 CST 2018, sex='女', address='北京金燕龙'}
User{id=45, username='传智播客', birthday=Sun Mar 04 12:04:06 CST 2018, sex='男', address='北京金燕龙'}
User{id=46, username='老王', birthday=Wed Mar 07 17:37:26 CST 2018, sex='男', address='北京'}
User{id=48, username='小马宝莉', birthday=Thu Mar 08 11:44:00 CST 2018, sex='女', address='北京修正'}
我们使用Mybatis框架就是要使sql语句和java代码解耦,因此实际开发中我们都是让Mybatis框架根据配置好的sql语句通过反射创建持久层实现类,而不会手动编写持久层实现类.但实际上,Mybatis框架允许我们这样做.
创建持久层实现类UserDaoImpl
如下:
package cn.maoritian.dao.impl;
public class UserDaoImpl implements IUserDao {
private SqlSessionFactory factory;
public UserDaoImpl(SqlSessionFactory factory) {
this.factory = factory;
}
public List<User> findAll() {
// 1.使用工厂创建SqlSession对象
SqlSession session = factory.openSession();
// 2.使用session执行查询所有方法
List<User> users = session.selectList("cn.maoritian.dao.IUserDao.findAll");
session.close();
// 3.返回查询结果
return users;
}
}
测试程序也应该做出相应更改如下:
package com.itheima.test;
public class MybatisTest {
public static void main(String[] args) throws Exception {
// 1.读取配置文件
InputStream config = Resources.getResourceAsStream("SqlMapConfig.xml");
// 2.创建SqlSessionFactory工厂
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(config);
// 3.使用工厂创建dao对象
IUserDao userDao = new UserDaoImpl(factory);
// 4.使用代理对象执行方法
List<User> users = userDao.findAll();
for (User user : users) {
System.out.println(user);
}
// 5.释放资源
in.close();
}
}
在入门案例中,有以下几点值得注意
静态资源的读取
对于实际项目中的静态资源,我们不论是用绝对路径或者相对路径,都是不合适的. 我们访问静态资源只有两种情况:
java源代码中resource
目录下的文件,构建项目后会被放到类路径下,因此我们通过类字节码或类加载器访问该静态资源.
// 返回当前类字节码所在路径,即 target/classes/类的包路径
this.getClass().getResource("").toString();
// 返回当前类字节码所在路径下的文件流,即 target/classes/类的包路径/path/file
this.getClass().getResourceAsStream("/path/file");
// 返回类路径,即 target/classes
this.getClass().getClassLoader().getResource("").toString();
// 返回类路径下的文件流,即 target/classes/path/file
this.getClass().getClassLoader().getResourceAsStream("/path/file");
在web项目中webapp
目录下的文件,构建项目后会被放到tomcat的web项目路径下,我们通过当前会话的ServletContext
访问该静态资源.
某项目在发布到http://localhost:8080/contextPath
路径下,在web.xml
中配置某Servlet的url-pattern
为/servletPath
.
在浏览器地址栏中输入http://localhost:8080/contextPath/servletPath
即可访问该Servlet.
// 返回当前web项目的实际(绝对)路径 "http://host/contextPath"
request.getSession().getServletContext().getRealPath("");
// 返回java源代码中 web-app目录下的文件流,即java源代码中 "web-app/path/file"
// 亦即web项目中的"http://host/contextPath/path/file"
request.getSession().getServletContext().getResourceAsStream("path/file");
request.getSession().getServletContext().getResourceAsStream("/path/file");
request.getContextPath(); // 返回"/contextPath"
request.getServletPath(); // 返回"/servletPath"
测试代码中创建持久层实现类时用到的几个设计模式
我们创建SqlSessionFactory
时用到了构建者模式
,我们将配置文件config
传递给SqlSessionFactoryBuilder
类的build()
方法,得到SqlSessionFactory
对象.
使用构建者模式
,我们将构建工厂类的细节(读取配置文件)隐藏,向外暴露为build()
方法
我们获取SqlSession
时用到了工厂模式
,通过SqlSessionFactory
类的openSession()
方法生产SqlSession
对象.
使用工厂模式
,我们降低了SqlSession
接口与其实现类之间的耦合
我们创建IUserDao
实现类时用到了代理模式
,通过动态代理的方法在不修改源代码的情况下对已有方法进行增强.
public static void main(String[] args) throws Exception {
// 1.读取配置文件
InputStream config = Resources.getResourceAsStream("SqlMapConfig.xml");
// 2.创建SqlSessionFactory工厂
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(config);
// 3.使用工厂创建dao对象
IUserDao userDao = new UserDaoImpl(factory);
// 4.使用代理对象执行方法
List<User> users = userDao.findAll();
for (User user : users) {
System.out.println(user);
}
// 5.释放资源
in.close();
}
分析入门案例中Mybatis框架的执行流程如下.
先读取出Mybatis主配置文件SqlMapConfig.xml
,其中记录的信息主要有两个
driver
,url
,username
,password
.这四个信息用来创建Connection
对象mappers
信息,mappers
信息记录的是持久层接口与其实现类sql语句之间的映射,每个持久层接口的mapper
信息都写在一个单独的文件中.这些信息被用来通过反射创建持久层实现类.对配置文件中的信息进行封装
我们将从配置文件中读取的所有信息封装到Configure
类中,其属性除了数据库链接信息driver
,url
,username
,password
以外,还有一个Map
属性,记录所有持久层方法与其sql语句的映射,其键为持久层方法的全限定方法名,值为该方法对应的Mapper
对象.
我们将每个持久层方法的sql语句和返回值类型封装成一个Mapper
对象,Mapper
类有两个属性,分别是queryString
表示方法执行的sql语句,resultType
表示方法返回值类型的全限定类名
我们将配置文件读取成流之后,传递给SqlSessionFactoryBuilder
对象,其build()
方法将配置文件流解析为Configuration
对象并返回一个工厂类SqlSessionFactory
接口的实现类DefaultSqlSessionFactory
对象,其构造函数接收一个Configuration
配置对象赋值给cfg
属性.
SqlSessionFactory
类的openSession()
方法开启一次数据库会话,即返回一个SqlSession
接口的默认实现类DefaultSqlSession
对象.其构造函数接收一个Configuration
配置对象赋值给cfg
属性并根据cfg
属性创建数据库链接Connection
对象.SqlSession
类的getMapper()
方法通过代动态理模式创建持久层接口IUserDao
的实现类.