文章目录
- Mybatis
-
- JDBC编程和存在问题
- mybatis原理
- mybatis使用demo
- 1、引入mybatis依赖
- 2、全局配置文件（mybatis-config.xml）
- 3、PoJo类（Student23.java）
- 4、Mapper接口文件（Student23Mapper.java）
- 5、Mapper.xml文件（Student23Mapper.xml）
- 6、全局配置文件引入映射文件
- 7、查询操作
- 配置详解
- 1、全局配置文件的介绍（mybatis-config.xml）
- 2、Mapper.xml文件详解
- 3、编码详解
- Junit测试介绍
- Junit的测试步骤
- 生产测试类
- Junit介绍
- mybatis的使用方法：配置和注解
- XML方式使用
- 1、创建mapper接口文件
- 2、创建mapper.xml文件
- 3、配置映射路径
- 注解方法使用
- SSM整合
- Spring和Mybatis的整合
- **整合步骤**
- 第一步：引入依赖
- 配置spring的配置文件
- 整合步骤
- 1.引入依赖
- 2.dao层处理
- 3.spring配置
- 4.spring mvc的处理
- 将spring的配置文件配置到web.xml文件中
Mybatis
1、Mybatis是一款优秀的持久层框架
2、它支持自定义SQL、存储过程以及高级映射
3、Mybatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作
4、Mybatis可以通过简单的XML或注解来配置和映射原始类型、接口和java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
参考mybatis资料：https://mybatis.org/mybatis-3/zh/index.html
JDBC编程和存在问题
jdbc编程回顾
public class JDBCDemo {
/**
* 1、引入依赖驱动包
* mysql-connector-java
* 2、加载驱动
* Class.forName("");
* 3、连接数据库，获取Connection
* url:jdbc:mysql/ip+port(3306)/数据库名
* username：
* password：
* Connection connection = DriverManager.getConnetion();
*
* 4、获取Statement对象
* Statement statement = connection.createStatement();
*
* 5、执行数据库的操作（CRUD）
* statement.executorQuery();
*
* 6、获取结果集：ResultSet
*
* 7、关闭资源
* statement.close();
* connection.close();
*/
//第一步：导入jar包
//第二步：说明JDBC驱动的名称和数据库的地址
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/test";
//第三步：说明数据库的认证账户及密码
static final String USER = "root";
static final String PASS = "123456";
public static void main(String[] args) {
//第四步：加载数据库驱动.通常使用Class.forClass(String driverName);加载
try {
Class.forName(JDBC_DRIVER);
} catch (ClassNotFoundException e) {
//这里会发生类没有找到的异常！
e.printStackTrace();
}
//第五步：获得数据库连接
try {
//获取连接
Connection connection = DriverManager.getConnection(DB_URL,USER,PASS);
//第六步：执行查询语句
Statement statement = connection.createStatement();
String sql = "SELECT * FROM Student where SID=1 ";
ResultSet rs =statement.executeQuery(sql);
while (rs.next())
{
String title = rs.getString("SID");
String author = rs.getString("Sname");
System.out.println(title+":"+author);
}
//第七步：关闭连接资源
rs.close();
statement.close();
connection.close();
} catch (SQLException e) {
e.printStackTrace();
//这里会发生SQL异常，因为我们提供的的账户和密码不一定能连接成功
}
}
jdbc存在的问题
总结：
1、数据库链接创建，释放频繁的操作造成系统的资源浪费，从而影响系统性能
2、SQL语句在代码中硬编码，造成代码不易维护，实际的应用SQL变化很大，SQL改变时要引起java代码的改变
3、对结果集的解析存在硬编码(查询列名)，SQL改变导致解析代码也会发生改变，系统不易维护
JDBC问题的解决方法
1、频繁进行数据库的连接和释放
解决：(复用链接)，通过连接池来解决，mybatis也能够进行链接的复用
2、SQL语句硬编码在java代码中
解决：SQL和java代码分离，SQL语句放置在配置文件中(xml)，需求改变仅需改变配置文件即可
3、返回结果集的硬编码
解决：数据库中的数据映射成JAVA对象
mybatis原理
整个mybatis的执行流程
mybatis使用demo
实际场景为例：通过ID来查询学习信息（对应的test库中Student表）
1、引入mybatis依赖
<!--mybatis的依赖-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.1</version>
</dependency>
2、全局配置文件（mybatis-config.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>
<!--配置数据源：必须-->
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/test"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<!--引入映射文件-->
<mappers>
<!--<mapper resource="org/mybatis/example/BlogMapper.xml"/>-->
</mappers>
</configuration
3、PoJo类（Student23.java）
public class Student23 {
private Integer SID;
private String Sname;
private String Ssex;
private String Sage;
}
注意：PoJo类中的属性名和数据库中的类中的列名保持一一对应，可自动完成映射
4、Mapper接口文件（Student23Mapper.java）
public interface Student23Mapper {
//通过id查询学生信息
public Student23 selectStudentByUid(Long uid);
}
5、Mapper.xml文件（Student23Mapper.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：命名空间，接口文件的全路径-->
<mapper namespace="com.tulun.inteface.Student23Mapper">
<!-- 通过id查询学生信息-->
<select id="selectStudentByUid" parameterType="long" resultType="com.tulun.pojo.Student23">
select * from Student where SID = #{
uid}
</select>
</mapper>
6、全局配置文件引入映射文件
<!--引入映射文件-->
<mappers>
<mapper resource="mapper/Student23Mapper.xml"/>
</mappers>
7、查询操作
public static void main(String[] args) throws IOException {
//获取全局配置文件
String path = "mybatis-config.xml";
//通过mybatis提供共的Resources类来获取配置文件流
InputStream inputStream = Resources.getResourceAsStream(path);
//获取SQLSessionFactory对象
SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//获取会话工厂
SqlSession sqlSession = sessionFactory.openSession();
//通过反射机制来后去到mapper的实例
Student23Mapper student23Mapper = sqlSession.getMapper(Student23Mapper.class);
Student23 student23 = student23Mapper.selectStudentByUid(1L);
System.out.println(student23);
}
使用步骤总结：
1、配置一个全局的配置文件数据源、引入映射文件
2、创建SQLSessionFactory对象（mybatis通过SqlSessionFactoryBuilder创建）
3、通过会话工厂创建SQLSession会话
4、通过SQLSessioin操作数据库
5、管理会话SQLSession
配置详解
1、全局配置文件的介绍（mybatis-config.xml）
参考资料文档：https://mybatis.org/mybatis-3/zh/configuration.html#settings
properties：读取外部资源
properties用来给定配置，可以进行动态的替换
<!--读取配置文件信息：动态的替换配置-->
<properties >
<property name="user" value="root"/>
<property name="pasword" value="123456"/>
</properties>
<!--配置数据源：必须-->
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/test"/>
<property name="username" value="${user}"/>
<property name="password" value="${pasword}"/>
</dataSource>
</environment>
</environments>
使用的配置在properties中给定例如：username和password，在指定的配置文件中db.propertis也给定了配置信息，即属性不只一个订房进行配置：mybatis提供如下加载顺序
首先读取的是properties元素体内指定的属性
在根据properties元素中的resource属性读取指定路径下的问题，如果存在相容的属性文件，则覆盖之前读取的同名的属性
最后读取防范参数传递的属性，覆盖之前读取的同名属性
注意：通过parameterType传递的属性具有最高优先级，resource或URL加载的属性次之，最低优先级的是properties元素体内指定的属性
setting：全局的参数配置
cacheEnabled:mybatis中提供的缓存机制，其中二级缓存的使用需要打开开关
lazyLoadingEnabled和aggressiveLazyLoading配置用来进行懒加载的开关配置
typeAliases：类型别名
类型别名是java的类型设置一个短的名字，只和XML配置 有关，用来减少类完全限定名的冗余的问题
在mapper.xml配置文件中，定义了很多的Statement，satement需要使用paramenterType指定输入参数类型，需要使用resultType来指定输出参数类型，指定类型的全路径，不方便开发，就可以在配置文件中配置别名，在mapper.xml文件中就可以使用定义别名
<!--类型别名-->
<typeAliases>
<!--定义单个别名 type属性：pojo类的全限定名 alias：别名的名称-->
<typeAlias type="com.tulun.pojo.Student23" alias="student23"/>
<!--批量的别名配置 name:指定包名，将包下的所有的pojo类定义别名,别名为类名(首字母大写小写都可以)-->
<package name="com.tulun.pojo"/>
</typeAliases>
environments：环境配置
mybatis支持多种环境的配置，方法在多个数据库间做切换，例如：开发环境，测试环境，生产环境
可以配置多个环境，但是在使用SQLSessionFactory实例只能选择一种环境
使用的默认环境：default=“development”
每一个环境environment元素定义的环境ID
事务管理器的配置：transactionManager
数据源的配置：dataSource
mappers：映射器
定义的SQL映射语句，告诉mybatis去哪查找SQL的语句，主要提供三种方式加载映射文件
<!--引入映射文件:在和spring整合后不需要在这里配置了-->
<mappers>
<!--resource方式:单个mapper的映射：定义的mapper.xml文件中namespace为maper接口的地址，
映射文件通过namespace找到对应的mapper的接口文件
mapper.xml文件和mapper的接口文件可以不放在一个目录下，且mapper.xml和mapper的及接口文件名可以不一致
-->
<mapper resource="mapper/Student23Mapper.xml"/>
<!--class方式：单个mapper的映射：遵循规则：将mapper.xml文件和mapper接口文件放在一个目录下，并且文件名保持一致-->
<mapper class="com.tulun.inteface.Student23Mapper"/>
<!--批量的mapper扫描：package方式:批量mapper映射：遵循规则：mapper.xml文件和mapper接口文件在同一目录下，且文件名相同-->
<package name="com.tulun.inteface"/>
</mappers>
2、Mapper.xml文件详解
主要关注CRUD便签
查询：select标签
插入：insert标签
变更：update标签
删除：delete便签
3、编码详解
SqlSessionFactoryBuilder
创建会话工厂实例SqlSessionFactory
SqlSessionFactory：会话工厂
通过读取配置文件，配置文件一次读取就可以实例化所有需要的会话，SqlSessionFactory设置为单例
通过SqlSessionFactory创建会话
SqlSession：会话
对数据库的CRUD操作都是通过SqlSession来操作的
SqlSession是线程不安全的，将其设置为局部变量
Junit测试介绍
测试是在开发过程中保证代码质量的必不可少的环境，开发人员常用的一键构建测试结构的功能，通过Junit做单元测试
Junit的测试步骤
引入依赖
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
生产测试类
Junit介绍
用来编写和运行可重复的自动化的开源测试框架
用来测试整个对象，对象的一部分，几个对象之间的交互
常用的注解
@Before:在Test注解中的方法执行之前会执行
@Test 单元测试的接口方法
@After：在Test直接之后执行
public class Student23MapperTest {
SqlSessionFactory sessionFactory = null;
/**
* 在编写测试方法之前，经常会在执行测试之前需要创建一些全局对象，单例对象啊
* 在运行用例即@Test注解之前运行
* @throws IOException
*/
@Before
public void before() throws IOException {
//获取全局配置文件
String path = "mybatis-config.xml";
//通过mybatis提供共的Resources类来获取配置文件流
InputStream inputStream = Resources.getResourceAsStream(path);
//获取SQLSessionFactory对象
sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
}
@Test
public void selectStudentByUid() throws IOException {
//获取会话工厂
SqlSession sqlSession = sessionFactory.openSession();
//通过反射机制来后去到mapper的实例，getMapper的参数是接口名
Student23Mapper student23Mapper = sqlSession.getMapper(Student23Mapper.class);
Student23 student23 = student23Mapper.selectStudentByUid(1L);
System.out.println(student23);
sqlSession.close();
}
@Test
public void selectStudentByName() throws IOException {
//获取会话工厂
SqlSession sqlSession = sessionFactory.openSession();
//通过反射机制来后去到mapper的实例，getMapper的参数是接口名
Student23Mapper student23Mapper = sqlSession.getMapper(Student23Mapper.class);
List <Student23> student23s = student23Mapper.selectStudentByName("TL%");
System.out.println(student23s.size());
sqlSession.close();
}
/**
* 在Test注解运行的方法之后运行
*/
@After
public void after() {
}
}
mybatis的使用方法：配置和注解
XML方式使用
1、创建mapper接口文件
public interface Student23Mapper {
//通过id查询学生信息
public Student23 selectStudentByUid(Long uid);
}
2、创建mapper.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：命名空间，接口文件的全路径（包名+类型）-->
<mapper namespace="com.tulun.inteface.Student23Mapper">
<!-- 通过id查询学生信息-->
<select id="selectStudentByUid" parameterType="long" resultType="student23">
select * from Student where SID = #{
uid}
</select>
</mapper>
<!--
resultMap标签
id属性：取名字
type属性：指定映射的pojo类对象的全路径
-->
<resultMap id="StudentMap" type="com.tulun.pojo.Student23">
<!--
id标签：指定的是主键的映射关系
result标签：非主键的映射关系
column属性：数据库字段的名称
property属性：pojo类中属性名
jdbcType属性：数据可字段的类型
javaType属性：指定java属性的类型
typeHandler属性：执行类型映射操作
-->
<id property="SID" column="SID" />
<result property="name" column="Sname"/>
<result property="Ssex" column="Ssex"/>
<result property="Sage" column="Sage"/>
</resultMap>
<!-- 通过id查询学生信息
select查询标签
id属性：对应接口中的方法名，在同一个namespace中，id是不能重复的
parameterType属性：指定入参类型
resultType属性：指定返回参数的类型，指定全路径名
resultMap属性：指定返回去参数类型
#{
XXX}:占位符，里面填写的就是方法中的参数名
resultMap和resultType区别：
使用resultType是需要数据库的字段和Java类的属性名保持一致，如果不一致则无法完成映射
使用resultMap进行显性的映射，可以解决数据库的字段和Java类的属性名不一致的问题
-->
<select id="selectStudentByUid" parameterType="long" resultMap="StudentMap">
select * from Student where SID = #{
uid}
</select>
<!--通过name查询用户信息-->
<select id="selectStudentByName" parameterType="string" resultType="student23">
select * from Student where Sname like #{
name}
</select>
插入操作
<!--
插入用户信息
id属性：接口的方法名，唯一不重复
parameterType属性：指定参数类型
useGeneratedKeys属性：获取有数据库内部生成的主键，默认是false，值可以是true和false
timeout属性：设置在抛出异常之前，等待数据库返回结果单额秒数
flushCache属性：用来清空一级缓存和二级缓存 默认值为true
-->
<insert id="insertStudent" parameterType="student23" >
insert into Student(SID,Sname,Ssex,Sage) values (#{
SID},#{
name},#{
Ssex},#{
Sage})
</insert>
3、配置映射路径
<!--引入映射文件:在和spring整合后不需要在这里配置了-->
<mappers>
<mapper resource="mapper/Student23Mapper.xml"/>
</mappers>
多个接口参数
以update为例
public int updateStudent1(@Param("SID") Long SID, @Param("name") String name)
在多个参数传递时，需要在方法参数上添加@Param注解，mybatis会自动将参数封装为Map类型，@Param注解值会作为Map的key，因此SQL会通过配置的注解值来使用参数
注解方法使用
注解形式将SQL直接写在接口上
@Insert注解
在接口方法上使用注解@Insert，将SQL直接写在该注解内
@Insert("insert into Student(SID,Sname,Ssex,Sage) values (#{SID},#{name},#{Ssex},#{Sage})")
public int insertStudent(Student23 student);
注意：在注解形式内也提供了类似xml方式提供的功能，包括自增注解，缓存开启等功能，需要将这些配置写在@Options注解内，如下：
@Options(useGeneratedKeys = true,timeout = 1000,useCache = true)
@Insert("insert into Student(SID,Sname,Ssex,Sage) values (#{SID},#{name},#{Ssex},#{Sage})")
public int insertStudent(Student23 student);
@Select操作
@Select("select * from Student where SID = #{uid}")
public Student23 selectStudentByUid(Long uid);
select注解使用如上，和xml方式中返回参数类型为parameterType类似，存在数据库列名和java的属性名不一致则无法完成映射
@Results({
@Result(property ="SID" ,column = "SID"),
@Result(property ="name" ,column = "Sname"),
@Result(property ="Sage" ,column = "Sage"),
@Result(property ="Ssex" ,column = "Ssex"),
})
以上写法类似于xml方式中通过resultMap返回结果集
@Results类似于xml中resultMap标签，@Result类似于result属性
mybatis注解形式如何共用
@Results返回参数映射的问题。需要共用的其他方法在上面添加一个@ResultMap注解，注解内的value值就是映射注解中的id值
SSM整合
Spring和Mybatis的整合
将mybatis中的实例交给spring管理
Spring通过单例方式来管理SQLSessionFactory
mybatis中SQLSessionFactory的创建是通过SQLSessionFactoryBuilder来创建实例化
在mybatis和spring的整合后，通过SQLSessionFactoryBean来替代，
SQLSessionFactoryBean必须给定一个属性dataSource
给定一个属性configLocation，用来指定mybatis的xml配置文件
整合步骤
第一步：引入依赖
spring的4个核心依赖、mybatis、jdbc…
需要一个依赖，是mybatis提供的，专门用来和spring整合，mybatis-spring
<!--mybatis的整合依赖-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.0</version>
</dependency>
配置spring的配置文件
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<!--配置连接池c3p0-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value=""/>
<property name="jdbcUrl" value=""/>
<property name="user" value=""/>
<property name="password" value=""/>
</bean>
<!--配置SQLSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--配置数据源-->
<property name="dataSource" ref="dataSource" />
</bean>
</beans>
需求：查询Student表中所有的学生信息
配置一个spring的配置文件，将mybatis的一些配置放入到spring，交给容器进行管理
数据源，会话工厂
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<!--配置数据源：借助连接池c3p0-->
<!--<bean id="datasource1" 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>-->
<bean id="datasource1" class="com.alibaba.druid.pool.DruidDataSource">
<!--注入属性值-->
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/test"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</bean>
<!--
创建SQLSessionFactory对象
sqlSessionFactory的类的全路径名是mybatis-spring包中提供的SqlSessionFactoryBean创建的
-->
<bean id="sqlSessionFactory" scope="singleton" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--数据库的连接配置-->
<property name="dataSource" ref="datasource1"/>
<!--配置mybatis的XML文件的路径-->
<property name="configLocation" value="classpath:Spring-mybatis.xml"/>
<!--
配置xml文件的映射
在mybatis学习中，该配置时在<mapper>标签下添加的
-->
<property name="mapperLocations">
<list>
<value>mapper/Student23Mapper.xml</value>
</list>
</property>
</bean>
<!--
通过代理模式进行Mapper映射开发
MapperFactoryBean是mybatis-spring包提供的完成映射的类
-->
<bean id="student23Mapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
<!--指定单个的mapper映射方式
mapperInterface属性：指定的是接口 value是接口的全路径
-->
<property name="mapperInterface" value="com.tulun.inteface.Student23Mapper"/>
<!--会话工厂-->
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>
<!--Student23Service交给spring管理-->
<bean id="student23Service" class="com.tulun.service.StudentService">
<!--注入mapper到当前的Service-->
<constructor-arg name="student23Mapper" ref="student23Mapper"/>
</bean>
</beans>
整合思路
web项目在后端controller层，service，dao层，使用框架SpringMVC，Spring，Mybatis
第一步：整合dao层
mybatis和spring整合，通过spring管理mapper接口
使用mapper的扫描器自动扫描mapper接口在spring中进行注册。
第二步：整合service层
通过spring管理service接口
使用配置方式将service接口配置在spring配置文件中。
实现事务控制
第三步：整合springMvc
由于springmvc是spring的模块，不需要整合。
整合步骤
需求：将test库中user表中的所有信息展示在页面
数据库如下：
select * from user;
+----+----------+--------+
| id | name | passwd |
+----+----------+--------+
| 1 | zhangsan | 1234 |
| 2 | 12345 | 1234 |
+----+----------+--------+
1.引入依赖
<!--Spring 基本核心jar包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${
spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${
spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${
spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>${
spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${
spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${
spring.version}</version>
</dependency>
<!--log4j日志-->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<!--Spring MVC依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${
spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${
spring.version}</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>
<!--mybatis-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.39</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.1</version>
</dependency>
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.1</version>
</dependency>
<!--mybatis和spring的整合-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.0</version>
</dependency>
2.dao层处理
pojo类，mapper.java，mapper.xml,mybatis的配置文件
mybatis的全局配置文件(spring-mybatis)
<?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>
<!--不需要配置信息-->
</configuration>
pojo类：
public class User {
private Long id;
private String name;
private String passswd;
}
mapper.java
public interface UserMapper {
public List<User> selectAllUser();
}
mapper.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="com.tulun.ssm.dao.UserMapper">
<!--selectAllUser-->
<select id="selectAllUser" resultType="com.tulun.ssm.pojo.User">
select * from user
</select>
</mapper>
3.spring配置
spring的配置文件(spring-core.xml)
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<!--通过扫描注解的形式来管理bean-->
<context:component-scan base-package="com.tulun.ssm"/>
<!--数据源-->
<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>
<!--配置会话工厂-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--数据源-->
<property name="dataSource" ref="datasource"/>
<!--XML配置文件-->
<property name="configLocation" value="spring-mybatis.xml"/>
<!--Mapper的映射-->
<property name="mapperLocations" value="mapper/*.xml"/>
</bean>
<!--代理对象-->
<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
<!--指定单个的mapper映射方式
mapperInterface属性：指定的是接口 value是接口的全路径
-->
<property name="mapperInterface" value="com.tulun.ssm.dao.UserMapper"/>
<!--会话工厂-->
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>
</beans>
注解形式来装配bean：以userService为例讲解
/**
* 通过注解形式来完成依赖注入和Bean管理
*/
@Service
public class UserService {
//将dao层对象注入到service层
@Autowired
UserMapper userMapper;
public List<User> allUsers(){
return userMapper.selectAllUser();
}
}
4.spring mvc的处理
配置web.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<!--配置前端控制器-->
<servlet>
<servlet-name>spring23</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>spring23</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
配置springMVC的配置文件（Spring-mvc.xml）
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
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-4.1.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">
<!--配置处理器适配器、处理器映射器、视图解析器-->
<!--通过扫描注解的形式来查找spring MVC的信息-->
<context:component-scan base-package="com.tulun.ssm.controller"/>
<!--通过这种形式可以不同配置处理器适配器和处理器映射器，采用默认的组件-->
<!--视图解析器：jsp-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--处理JSP页面-->
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
<!--前缀-->
<property name="prefix" value="/WEB-INF/jsp/"></property>
<!--后缀-->
<property name="suffix" value=".jsp"/>
</bean>
</beans>
配置springMVC的配置文件（Spring-mvc.xml）
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
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-4.1.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">
<!--配置处理器适配器、处理器映射器、视图解析器-->
<!--通过扫描注解的形式来查找spring MVC的信息-->
<context:component-scan base-package="com.tulun.ssm.controller"/>
<!--通过这种形式可以不同配置处理器适配器和处理器映射器，采用默认的组件-->
<!--视图解析器：jsp-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--处理JSP页面-->
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
<!--前缀-->
<property name="prefix" value="/WEB-INF/jsp/"></property>
<!--后缀-->
<property name="suffix" value=".jsp"/>
</bean>
</beans>
页面jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>数据展示</title>
</head>
<body>
<table align="center" border="1">
<thead>
<tr>
<td>用户id</td>
<td>用户名</td>
<td>密码</td>
</tr>
</thead>
<tbody>
<c:forEach items="${users}" var="user">
<tr>
<td>${
user.id}</td>
<td>${
user.name}</td>
<td>${
user.passswd}</td>
</tr>
</c:forEach>
</tbody>
</table>
</form>
</body>
</html>
controller
@Controller
public class UserController {
//将service层对象注入到Controller层
@Autowired
UserService userService;
@RequestMapping("/index")
public ModelAndView userList(){
List <User> users = userService.allUsers();
ModelAndView modelAndView = new ModelAndView();
modelAndView.addObject("users",users);
modelAndView.setViewName("userList");
return modelAndView;
}
}
将spring的配置文件配置到web.xml文件中
<!-- 加载spring容器：Spring和mybatis的配置文件 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-core.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>