jy-10-SPRINGMYBATIS01——MyBatis-程祖红／刘苍松

目录：

1、day01-MyBatis-程祖红

2、day07－MyBatis－刘苍松

文件已上传分享

3、day08－SSM－刘苍松

文件已上传分享

---

@程祖红

1、day01-MyBatis

(1)MyBatis是什么?

开源的持久层框架，底层仍然是jdbc。

（了解）

jdbc: 需要写sql,易掌握、性能好，代码繁琐，易出错。

hibernate: 难掌握，性能不好(复杂的查询经常需要优化sql)，代码简洁，可以不写sql。

MyBatis:比较容易掌握，性能一般，代码简洁，需要写sql。

---

(2)编程步骤

step1. 导包。

    mybatis,ojdbc,junit

step2. 添加MyBatis配置文件（SqlMapConfig.xml）。

  文件已上传分享

step3. 添加实体类。

        注：实体类的属性名要和表的字段名一样（大小写可以忽略）

step4. 添加映射文件。

        注：存放sql语句。

        不要忘记修改MyBatis配置文件，指定映射文件的位置。

文件已上传分享

 step5. 调用MyBatis的api访问数据库。

---

(3)原理 (了解)

  

---

(4)返回Map类型的结果

---

(5)解决实体类的属性名与表的字段名不一致的情况

1)方式一 使用别名

比如

SELECT id empNo,ename name,salary,age ...

2)方式二 使用resultMap元素

day02

1.Mapper映射器

(1)什么是Mapper映射器?

符合映射文件要求的接口。

---

(2)如何写Mapper映射器?

a.方法名必须与sqlId一样。

b.参数类型必须与parameterType一样。

c.返回类型必须与resultType一样。

d.映射文件中的namespace必须与Mapper映射器全限定名一样.

全限定名：包名加类名。

---

(3)如何使用Mapper映射器?

SqlSession.getMapper()会返回符合Mapper映射器要求的对象，

我们只需要调用该对象的方法，即可访问数据库。

---

2.Spring集成MyBatis (使用Mapper映射器)

1)编程步骤

step1.导包。

spring-webmvc,mybatis,mybatis-spring,spring-jdbc

ojdbc,dbcp,junit

step2.添加Spring配置文件。

    注： mybatis配置信息使用一个bean

    (SqlSessionFactoryBean)来代替。

step3.配置SqlSessionFactoryBean。

      作用：

整合应用提供SqlSession对象资源

        该bean的作用是用来代替MyBatis配置文件 

还可以定义一些属性来指定Mybatis框架的配置信息

step4.实体类

step5.映射文件

step6.Mapper映射器 

step7.配置MapperScannerConfigurer。

     作用：

 根据指定包批量扫描Mapper接口并生成实列

    注：

        该bean会扫描指定包及其子包下面的所有的

        Mapper映射器，然后调用SqlSession的getMapper

        方法，并把方法的返回值（即实现了Mapper映射器

        接口要求的对象）放到Spring容器里面（默认的id

        是首字母小写之后的接口名）。

2)只扫描带有特定注解的Mapper映射器

step1.开发一个注解。

step2.将该注解添加到Mapper映射器前面。

step3.配置MapperScannerConfigurer,指定注解。

练习：

    使用Spring + MyBatis 完成部门表的增删改查操作。

---

3.Spring集成MyBatis(不使用Mapper映射器 old)

(1)编程步骤

step1.导包。(同上)

step2.添加Spring配置文件。

step3.配置SqlSessionFactoryBean。（同上）

step4.实体类。

step5.映射文件。

    注： 映射文件的namespace不作要求。

step6.DAO接口。

    注： 不要求与映射文件一致。

step7.DAO实现类。

    注：  注入SqlSessionTemplate

    （封装了SqlSession的一些方法,这样，我们不用考虑如何获取

    SqlSession,如何关闭SqlSession,也不用关注事务提交）。

step8.配置SqlSessionTemplate。

使用SpringMVC + Spring + MyBatis完成登录

step1.导包。

    增加  mybatis,mybatis-spring,spring-jdbc

step2.添加SqlSessionFactoryBean。

step3.实体类

    注： 不用写了，直接用以前的，但是注意属性名与表的字段

    名不一致，建议使用别名来解决。

step4.添加UserMapper.xml

    注：

namespace="cn.tedu.login.dao.UserDAO"
<select id="findByUsername"
parameterType="string"
resultType="cn.tedu.login.entity.User">
SELECT id ...
</select>

step5.Mapper映射器 

    注： 不用写了( UserDAO就是)。

step6.配置MapperScannerConfigurer。

step7.测试UserDAO。

---

@刘苍松版

2、day07－MyBatis

用于解决软件持久化层的问题，可以实现持久化层0编码。 MyBatis底层封装的JDBC，所以在使用MyBatis时候需要导入JDBC驱动。

MyBatis 参考文件：

tctm-art-student-fe

---

MyBatis 结构

MyBatis封装了jdbc，提供了核心操作接口SqlSession，利用SqlSession就可以操作MyBatis提供的一切功能。使用MyBatis需要提供两个配置文件，分别用于管理数据库连接，和管理数据访问接口的和SQL的映射关系。

MyBatis的使用步骤：

1.在pom.xml文件中 导包

文件已上传分享

        <dependencies>
            <dependency>
                <groupId>commons-dbcp</groupId>
                <artifactId>commons-dbcp</artifactId>
                <version>1.4</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>3.2.8.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>1.2.3</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.2.8</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.37</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>3.2.8.RELEASE</version>
            </dependency>
        </dependencies>

2.编写数据库配置文件用于链接数据库－db.properties

文件已上传分享

url=jdbc:mysql://localhost:3306/springmvc
driver=com.mysql.jdbc.Driver
username=root
password=
initsize=1
maxsize=5

3.编写配置文件用于构建 构建出 SqlSessionFactory 的实例－ 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"> 
 <!-- XML 配置文件（config.xml）中包含了对      MyBatis 系统的核心设置，包含获取数据库连接实例的      数据源（DataSource）和决定事务范围和控制方式的事      务管理器（TransactionManager）。XML 配置文件的      详细内容后面再探讨，这里先给出一个简单的示例：  -->
<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/springmvc"/>   
<property name="username" value="root"/>    
<property name="password" value=""/> 
</dataSource>  
</environment> 
</environments>
<mappers>
<!-- 映射文件的地址 --> 
<mapper resource="mapping/userMapper.xml"/>
</mappers>
</configuration>

4.配置映射文件用语编写sql－mapper/userMapper.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">
<!-- 在命名空间“cn.tedu.mybatis.dao.IUserDao”中定义了一个名为
“selectUser”的映射语句，这样它就允许你使用指定的完全限定名
“cn.tedu.mybatis.dao.IUserDao.selectUser”来调用映射语句，
-->
<mapper namespace="cn.tedu.mybatis.dao.IUserDao">
<!-- 这条sql语句用语查询表中左右数据 resulType:结果类型-->

<select id="selectUser" resultType="cn.tedu.mybatis.bean.User">
select id,username,password,salary from user
</select>
</mapper>

5.编写一个实体类User类，－cn.tedu.mybatis.bean包下User

定义:

属性、get/set方法、无参构造、全参构造、全参构造、toString()方法

文件已上传分享

package cn.tedu.mybatis.bean;
public class User {
    private Integer id;
    private String username;
    private String password;
    private Integer salary;
    //篇幅太长，此处省略

}

6.创建命名空间类－cn.tedu.mybatis.dao/IUserDao

文件已上传分享

package cn.tedu.mybatis.dao;

import java.util.List;

import cn.tedu.mybatis.bean.User;

public interface IUserDao {
    /*** 查询所有用户* @return*/
    public List<User> selectUser();
}

7.创建测试类测试结果－ cn.tedu.mybatis.test/ MybatisTestCase

文件已上传分享

package cn.tedu.mybatis.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;
import cn.tedu.mybatis.bean.User;
import cn.tedu.mybatis.dao.IUserDao;
public class MybatisTestCase {
    SqlSessionFactory factory;
    /**
     * 初始化方法
     * @throws IOException
     */
    @Before
    public void init() throws IOException {
        String config ="config.xml";
        InputStream in= Resources.getResourceAsStream(config);
        factory = new SqlSessionFactoryBuilder().build(in);
    }
    /**
     * 查询所有数据
     */
    @Test
    public void testSelect() {
        SqlSession session = factory.openSession();
        IUserDao dao  = session.getMapper(IUserDao.class);
        List<User> list =dao.selectUser();
        for(User user :list) {
            System.out.println(user);
        }
        session.close();
    }
}

8.项目目录如下：

MyBatis实现查询功能

MyBatis实现查询非常方便：

1. 在IUserDao中声明接口方法

   /**
   *
   查询全部的用户信息 */ public List findAllUsers();

2. 在 userMapper.xml 中声明SQL语句
   <!-- MyBatis 会自动的将查询结果中列名与User的Bean属性

   对应赋值，如果表的列名与User Bean属性 列名不一致，则

   需要使用列的别名方式修改查询结果列名，使其与User Bean属性

   一致。-->

   <select id="findAllUsers"
   resultType="cn.tedu.mybatis.bean.User">
      select id, username, password, salary from user
   </select>

   resultType 用于声明返回值类型，其类型与返回的List中元素类型一致。

3. 测试：
       /**
        * 查询全部用户信息
        */
       @Test
       public void testFindAllUsers() {
   
           SqlSession session = factory.openSession();
           IUserDao dao =
                   session.getMapper(IUserDao.class);
           List<User> list = dao.findAllUsers();
           for (User user : list) {
               System.out.println(user);
           }
           session.close();
       }

---

SqlSession 接口也可以直接执行SQL

案例：

    /**
     * 利用SqlSession直接执行SQL，不访问DAO接口
     * 与访问dao接口的结果完全一样。
     * SqlSession提供了两种执行SQL功能
     */
    @Test
    public void testInsert() {

        SqlSession session = factory.openSession();
        //session.insert("SQL ID", 参数对象)
        User user = new User();
        user.setUsername("Andy");
        user.setPassword("123");
        user.setSalary(200);
        System.out.println(user);//id=null
        Integer n = session.insert("insertUser", user);
        System.out.println(user);//id=?
        System.out.println(n);
        session.commit();
        session.close();
    }

---

MyBatis实现更新和删除功能

1. 添加 接口方法
   /**
   * iUserDao 中添加更新方法，将用户信息进行更新
   * @param user 需要更新的用户信息
   * @return 更新的行数
   */
   public Integer updateUser(User user);
   
   public User findUserById(Integer id);
   
   public Integer deleteUserById(Integer id);

2. 添加SQL
   <update id="updateUser" parameterType="cn.tedu.mybatis.bean.User">
       update user set
       username=#{username},
       password=#{password},
       salary=#{salary}
       where
       id=#{id}
   </update>
   <select id="findUserById" resultType="cn.tedu.mybatis.bean.User" parameterType="int">
       SELECT
           id,
           username,
           PASSWORD,
           salary
           FROM
           USER
       WHERE
           id = #{id}
   </select>
   <delete id="deleteUserById"  parameterType="int">
       delete from user where id=#{id}
   </delete>

3. 测试

       /**
        * 测试更新用户信息方法
        * 1. 查询出用户信息
        * 2. 更改用户信息
        */
       @Test
       public void testUpdateUser(){
           SqlSession session = factory.openSession();
           IUserDao dao = session.getMapper(IUserDao.class);
           User user=dao.findUserById(10);
           System.out.println(user);
           user.setUsername("范XX");
           int n = dao.updateUser(user);
           System.out.println(n);
           session.commit();
           session.close();
       }
       
       /**
        * 测试删除用户的方法
        */
       @Test
       public void testDeleteUserById(){
           SqlSession session=factory.openSession();
           IUserDao dao=session.getMapper(IUserDao.class);
           int id=12;
           int n = dao.deleteUserById(id);
           System.out.println(n);
           session.commit();
           session.close();
       }

---

多参数查询

如果有多个参数，则可以利用 @Param 注解标注参数名，在SQL语句中使用 #{参数名} 绑定参数。

案例：

1. 声明接口方法
   /**
   * MyBatis中多参数查询 要使用注解 @Param 绑定参数名
   * 在SQL中，要使用参数名来绑定参数 #{salary}
   * @param salary
   * @param name
   * @return
   */
   public List<User> findUsersByParam(
   @Param("salary") Integer salary,
   @Param("name") String name);

2. 声明 SQL

   <select id="findUsersByParam" resultType="cn.tedu.mybatis.bean.User">
   SELECT
   	id,
   	username,
   	PASSWORD,
   	salary
   FROM
   	USER
   WHERE
   	username LIKE #{name} and
   	salary >= #{salary}
   </select>

3. 测试

       /**
        * 测试多参数查询
        */
       @Test
       public void testFindUserByParam(){
           String name="%a%";
           Integer salary = 200;
           SqlSession session=factory.openSession();
           IUserDao dao=session.getMapper(IUserDao.class);
           List<User> list=
                   dao.findUsersByParam(salary, name);
           for (User user : list) {
               System.out.println(user);
           }
           session.close();
       }

---

利用Map封装返回部分列

如果需要返回部分列，可以利用Map封装查询结果。

原理：

案例：

1. 声明接口方法
   /**
   * 用Map封装查询结果
   *
   */
   public List<Map<String, Object>> findUsersByMap();

2. 声明 SQL

   <select id="findUsersByMap" resultType="map">
   select
   id, username as name
   from
   user
   </select>

   username as name 当使用了别名时候，则别名做为map中的key。

3. 测试：

       /**
        * 测试：利用map封装查询结果
        */
       @Test
       public void testFindByMap(){
           SqlSession session=factory.openSession();
           IUserDao dao=session.getMapper(IUserDao.class);
           List<Map<String, Object>> list=
                   dao.findUsersByMap();
           for (Map<String, Object> map : list) {
               System.out.println(map);
           }
           session.close();
       }
   

---

利用 ${} 实现SQL拼接功能

其原理为：

实现步骤：

1. 声明 接口方法

   /**
   * 动态拼接SQL
   */
   public List<User> findUsers(
   @Param("where") String where,
   @Param("param") Object param);

2. 声明 SQL

   <select id="findUsers"
   resultType="cn.tedu.mybatis.bean.User">
   select
   id, username, password, salary
   from
   user
   where
   ${where} #{param}
   </select>

3. 测试

       @Test
       public void testFindUsers(){
           String where="username like ";
           Object param="%a%";
           SqlSession session=factory.openSession();
           IUserDao dao=session.getMapper(IUserDao.class);
           List<User> list=dao.findUsers(where, param);
           for (User user : list) {
               System.out.println(user);
           }
           session.close();
       }

---

整合 MyBatis和Spring

MyBatis 提供了Spring 整合包：

<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.1</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>3.2.8.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>3.2.8.RELEASE</version>
</dependency>
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.4</version>
</dependency>

整合步骤：

1. 导入相关包
2. 添加数据库连接参数文件 db.properties
   url=jdbc:mysql://localhost:3306/springmvc
   driver=com.mysql.jdbc.Driver
   username=root
   password=
   initsize=1
   maxsize=5

3. 添加Spring 配置文件 applocationContext.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:jdbc="http://www.springframework.org/schema/jdbc" 
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
<!-- 读取db.properties -->
<util:properties id="dbConfig" location="classpath:db.properties"></util:properties>
<!-- 配置dbcp所需要的bean -->
<bean id="ds" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="#{dbConfig.driver}"></property>
<property name="url" value="#{dbConfig.url}"></property>
<property name="username" value="#{dbConfig.username}"></property>
<property name="password" value="#{dbConfig.password}"></property>
<property name="initialSize" value="#{dbConfig.initsize}"></property>
<property name="maxActive" value="#{dbConfig.maxsize}"></property>
</bean>
<!-- 利用mybatis-spring配置SqlSessionFactory
FactoryBean 是工厂bean,自动创建SqlSessionFactory
类型的对象，所以配置SqlSessionFactoryBean但返回的
对象类型是SqlSessionFactory
-->
<bean id="sqlSessionFactory"
class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="ds"></property>
<!-- 帮我们加载映射文件 -->
<property name="mapperLocations" value="classpath:mapping/*.xml"></property>
</bean>
<!-- mybatis-spring提供了mapper(dao)接口：自动扫描功能
会自动找到全部的mapper(dao)接口，并且为每个接口创建
一个对象，并且将对象做为Bean存放在Spring容器中，如：、
扫描到IUserDao接口，就会自动创建一个Bean储存到Spring
中，其中Bean id 自动设定为iUserDao
-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
<!-- 设置扫描路径 设置扫描位置 -->
<property name="basePackage" value="cn.tedu.mybatis.dao" ></property>
</bean>
</beans>

1. 测试：

文件已上传分享

import java.util.List;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.tedu.mybatis.bean.User;
import cn.tedu.mybatis.dao.IUserDao;
public class MyBatisTestCase {
    ClassPathXmlApplicationContext ctx;
    @Before
    public void init() {
        ctx =new ClassPathXmlApplicationContext("applicationContext.xml");
    }
    /**
     * 测试由Spring管理的
     */
    @Test
    public void testSqlSessionFactory() {
        SqlSessionFactory factory =ctx.getBean(
                "sqlSessionFactory",SqlSessionFactory.class);
        System.out.println(factory);
    }
    @Test
    public void testIuserDao() {
        IUserDao dao = ctx.getBean("IUserDao",IUserDao.class);
        List<User> list =dao.findAllUsers();
        System.out.println(dao);
        for(User user : list) {
            System.out.println(user);
        }
    }
}

---

3、day08－SSM

SSM应用搭建

1.部署Spring + Spring MVC

1. 导入包
   <dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis</artifactId>
   <version>3.2.8</version>
   </dependency>
   <dependency>
   <groupId>mysql-connector-java</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>5.1.37</version>
   </dependency>
   <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.12</version>
   </dependency>
   <dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis-spring</artifactId>
   <version>1.3.1</version>
   </dependency>
   <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>3.2.8.RELEASE</version>
   </dependency>
   <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-jdbc</artifactId>
   <version>3.2.8.RELEASE</version>
   </dependency>
   <dependency>
   <groupId>commons-dbcp</groupId>
   <artifactId>commons-dbcp</artifactId>
   <version>1.4</version>
   </dependency>

2. 配置Spring MVC的前端控制器web.xml：
   <servlet>
   <description></description>
   <display-name>DispatcherServlet</display-name>
   <servlet-name>DispatcherServlet</servlet-name>
   <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
   <init-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>classpath:conf/spring-*.xml</param-value>
   </init-param>
   <load-on-startup>1</load-on-startup>
   </servlet>
   <servlet-mapping>
   <servlet-name>DispatcherServlet</servlet-name>
   <url-pattern>*.do</url-pattern>
   </servlet-mapping>

   Spring配置文件村存在conf文件夹中，并且其文件名符合spring - *。xml规则。

3. 添加数据库连接参数文件conf / db.properties
   url=jdbc:mysql://localhost:3306/tedustore
   driver=com.mysql.jdbc.Driver
   user=root
   password=root
   initsize=1
   maxsize=5

4. 添加数据库连接池配置文件spring-db.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:jdbc="http://www.springframework.org/schema/jdbc"
   xmlns:jee="http://www.springframework.org/schema/jee"
   xmlns:tx="http://www.springframework.org/schema/tx"
   xmlns:aop="http://www.springframework.org/schema/aop"
   xmlns:mvc="http://www.springframework.org/schema/mvc"
   xmlns:util="http://www.springframework.org/schema/util"
   xmlns:jpa="http://www.springframework.org/schema/data/jpa"
   xsi:schemaLocation="
   http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
   http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
   http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
   http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
   http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
   http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
   <!-- conf/spring-db.xml 用于管理数据库的连接 -->
   <!-- 读取conf/db.properties -->
   <util:properties id="dbConfig"
   location="classpath:conf/db.properties" />
   <!-- 配置DBCP所需的Bean -->
   <!-- 各property中的name以类中的set方法名称为准 -->
   <bean id="ds"
   class="org.apache.commons.dbcp.BasicDataSource">
   <property name="driverClassName"
   value="#{dbConfig.driver}"/>
   <property name="url"
   value="#{dbConfig.url}"/>
   <property name="username"
   value="#{dbConfig.user}"/>
   <property name="password"
   value="#{dbConfig.password}"/>
   <property name="initialSize"
   value="#{dbConfig.initsize}"/>
   <property name="maxActive"
   value="#{dbConfig.maxsize}"/>
   </bean>
   </beans>

5. 添加Spring MVC配置文件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:jdbc="http://www.springframework.org/schema/jdbc"
   xmlns:jee="http://www.springframework.org/schema/jee"
   xmlns:tx="http://www.springframework.org/schema/tx"
   xmlns:aop="http://www.springframework.org/schema/aop"
   xmlns:mvc="http://www.springframework.org/schema/mvc"
   xmlns:util="http://www.springframework.org/schema/util"
   xmlns:jpa="http://www.springframework.org/schema/data/jpa"
   xsi:schemaLocation="
   http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
   http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
   http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
   http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
   http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
   http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
   <!-- conf/spring-mvc.xml 用于管理MVC的配置 -->
   <context:component-scan
   base-package="cn.tedu.spring" />
   <mvc:annotation-driven/>
   <bean
   class="org.springframework.web.servlet.view.InternalResourceViewResolver">
   <property name="prefix" value="/WEB-INF/jsp/"></property>
   <property name="suffix" value=".jsp"></property>
   </bean>
   </beans>

6. 部署测试...

2.部署Spring MyBatis

1. 导入包（略）
2. 添加Spring MyBatis配置文件spring-mybatis.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:jdbc="http://www.springframework.org/schema/jdbc"
   xmlns:jee="http://www.springframework.org/schema/jee"
   xmlns:tx="http://www.springframework.org/schema/tx"
   xmlns:aop="http://www.springframework.org/schema/aop"
   xmlns:mvc="http://www.springframework.org/schema/mvc"
   xmlns:util="http://www.springframework.org/schema/util"
   xmlns:jpa="http://www.springframework.org/schema/data/jpa"
   xsi:schemaLocation="
   http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
   http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
   http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
   http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
   http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
   http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
   <!-- conf/spring-mybatis.xml 用于管理MVC的配置 -->
   <bean id="sqlSessionFactory"
   class="org.mybatis.spring.SqlSessionFactoryBean">
   <property name="dataSource" ref="ds"/>
   <!--
   <property name="mapperLocations"
   value="classpath:mapping/*.xml"/> -->
   </bean>
   <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
   <property name="sqlSessionFactory"
   ref="sqlSessionFactory"/>
   <property name="basePackage"
   value="cn.tedu.store.dao"/>
   </bean>
   </beans>

   其中mapperLocations属性被临时注释掉了，再以后有映射文件以后打开。

3. 利用JUnit进行离线测试：

   public class MyBatisTest {
       ClassPathXmlApplicationContext ctx;
       @Before
       public void init(){
           ctx = new ClassPathXmlApplicationContext(
                   "conf/spring-db.xml",
                   "conf/spring-mybatis.xml");
       }
       @Test
       public void testSqlSession(){
           SqlSessionFactory factory=
                   ctx.getBean("sqlSessionFactory",
                           SqlSessionFactory.class);
           SqlSession session=factory.openSession();
           System.out.println(session);
           session.close();
       }
   }

---

实现用户列表功能

原理： 

数据层

实现步骤：

1. 数据表结构：

   desc user;
   +-------------+-------------+------+-----+-------------------+-----------------------------+
   | Field | Type | Null | Key | Default | Extra |
   +-------------+-------------+------+-----+-------------------+-----------------------------+
   | id | int(11) | NO | PRI | NULL | auto_increment |
   | username | varchar(20) | YES | | NULL | |
   | password | varchar(30) | YES | | NULL | |
   | email | varchar(20) | YES | | NULL | |
   | mobile | varchar(20) | YES | | NULL | |
   | create_time | timestamp | NO | | CURRENT_TIMESTAMP | on update CURRENT_TIMESTAMP |
   +-------------+-------------+------+-----+-------------------+-----------------------------+

2. 添加实体类用户

   import java.io.Serializable;
   
   public class User implements Serializable {
       private static final long serialVersionUID = -7291170424207323214L;
       private Integer id;
       private String username;
       private String password;
       private String mobile;
       private String email;
       private Date createTime;
       public User() {
       }
       public User(Integer id, String username, String password, String mobile, String email, Date createTime) {
           super();
           this.id = id;
           this.username = username;
           this.password = password;
           this.mobile = mobile;
           this.email = email;
           this.createTime = createTime;
       }
       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 String getPassword() {
           return password;
       }
       public void setPassword(String password) {
           this.password = password;
       }
       public String getMobile() {
           return mobile;
       }
       public void setMobile(String mobile) {
           this.mobile = mobile;
       }
       public String getEmail() {
           return email;
       }
       public void setEmail(String email) {
           this.email = email;
       }
       public Date getCreateTime() {
           return createTime;
       }
       public void setCreateTime(Date createTime) {
           this.createTime = createTime;
       }
       @Override
       public String toString() {
           return "User [id=" + id + ", username=" + username + ", password=" + password + ", mobile=" + mobile
                   + ", email=" + email + ", createTime=" + createTime + "]";
       }
       @Override
       public int hashCode() {
           final int prime = 31;
           int result = 1;
           result = prime * result + ((id == null) ? 0 : id.hashCode());
           return result;
       }
       @Override
       public boolean equals(Object obj) {
           if (this == obj)
               return true;
           if (obj == null)
               return false;
           if (getClass() != obj.getClass())
               return false;
           User other = (User) obj;
           if (id == null) {
               if (other.id != null)
                   return false;
           } else if (!id.equals(other.id))
               return false;
           return true;
       }
   }

3. 声明道接口

   public interface UserDao {
   /**
   * 查询全部的用户信息
   * @return 用户信息列表
   */
   List<User> findAllUsers();
   }

4. 添加映射配置文件映射/ userMapper.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="cn.tedu.store.dao.UserDao">
       <!-- mapping/userMapper.xml 映射文件 -->
       <!--
       result: 结果
       parameter: 参数
       type: 类型
       resultType: 用于声明方法的返回结果元素的类型
       parameterType: 参数的类型，当方法只有一个参数时候使用！
       如果有更多个参数建议使用 @Param 注解标注
       -->
       <select id="findAllUsers" resultType="cn.tedu.store.bean.User">
           SELECT
               id,
               username,
               PASSWORD,
               mobile,
               email,
               create_time AS createTime
           FROM
               USER    
       </select>
   
   </mapper>

5. 更新db.properties
   url=jdbc:mysql://localhost:3306/tedustore

6. 更新spring-mybatis.xml

   <property name="mapperLocations"
   value="classpath:mapping/*.xml"/>

7. 利用JUnit的进行离线测试

   public class UserDaoTest {
       ClassPathXmlApplicationContext ctx;
       UserDao dao;
       @Before //在全部测试案例之前执行的方法
       public void init(){
           ctx = new ClassPathXmlApplicationContext(
                   "conf/spring-db.xml",
                   "conf/spring-mybatis.xml");
           dao = ctx.getBean("userDao",UserDao.class);
       }
       @After //全部测试案例执行之后执行 destory方法
       public void destory(){
           ctx.close();
       }
   
       @Test
       public void testFindAllUsers(){
           List<User> list=dao.findAllUsers();
           for (User user : list) {
               System.out.println(user);
           }
       }
   }

2.业务层

步骤

1. 声明业务层接口

   public interface UserService {
   /**
   * 获取全部用户信息
   * @return 用户信息
   */
   List<User> list();
   }

2. 实现业务层

   @Service("userService") //当前类是业务层组件
   public class UserServiceImpl implements UserService {
       @Resource
       private UserDao userDao;
       public List<User> list() {
   //调用数据层处理业务
           return userDao.findAllUsers();
       }
   }

3. 添加配置文件spring-service.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:jdbc="http://www.springframework.org/schema/jdbc"
   xmlns:jee="http://www.springframework.org/schema/jee"
   xmlns:tx="http://www.springframework.org/schema/tx"
   xmlns:aop="http://www.springframework.org/schema/aop"
   xmlns:mvc="http://www.springframework.org/schema/mvc"
   xmlns:util="http://www.springframework.org/schema/util"
   xmlns:jpa="http://www.springframework.org/schema/data/jpa"
   xsi:schemaLocation="
   http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
   http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
   http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
   http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
   http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
   http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
   <!-- conf/spring-service.xml 用于管理业务层 -->
   <context:component-scan
   base-package="cn.tedu.store.service" />
   </beans>

4. 测试：
   public class UserServiceTest {
       ClassPathXmlApplicationContext ctx;
       UserService service;
       @Before
       public void init(){
           ctx=new ClassPathXmlApplicati onContext(
                   "conf/spring-service.xml",
                   "conf/spring-mybatis.xml",
                   "conf/spring-db.xml");
           service = ctx.getBean("userService",
                   UserService.class);
       }
       @After
       public void destory(){
           ctx.close();
       }
       @Test
       public void testList(){
           List<User> list=service.list();
           for (User user : list) {
               System.out.println(user);
           }
       }
   }

3.控制器和界面

1. 添加控制器类

   /**
    * 控制器，用于处理用户有关的业务功能
    */
   @Controller
   @RequestMapping("/user")
   public class UserController {
       @Resource
       private UserService userService;
   
       @RequestMapping("/users.do")
       public String users(ModelMap map) {
           //访问业务层获取全部用户信息
           List<User> list = userService.list();
           map.put("users", list);
           //System.out.println(list);
           //转发到JSP页面，显示结果
           return "user/list";
       }
   }

2. 重用的Servlet项目的界面

 

1. 测试

 

---

翻页功能

原理：

1.重构数据层

1. 重构Dao接口，添加翻页参数和行数统计方法

   /**
   * 查询全部的用户信息
   * @return 用户信息列表
   */
   List<User> findAllUsers(
   @Param("start") int start,
   @Param("size") int size);
   /**
   * 统计用户的数量
   */
   int countUsers();

2. 在userMapper.xml中声明SQL
   <select id="findAllUsers" resultType="cn.tedu.store.bean.User">
       select
           id,
           username,
           password,
           mobile,
           email,
           create_time as createTime
       from
            user
       limit #{start},#{size}
   </select>
   <select id="countUsers" resultType="int">
       SELECT count(*) FROM USER
   </select>

   SQL语句需要使用resultType =“int”声明返回值，DML语句不需要声明返回值类型，会自动返回int值。

3. 测试

    @Test
    public void testFindAllUsers(){
        List<User> list=dao.findAllUsers(4,4);
        for (User user : list) {
            System.out.println(user);
        }
    }

    @Test
    public void testCountUsers(){
        int n = dao.countUsers();
        System.out.println(n);
    }

2.重构业务层

1. 重构业务层方法UserService

   /**
   * 获取全部用户信息
   * @return 用户信息
   */
   List<User> list(Integer page);
   
   /**
   * 获取用户信息的页数
   */
   int listPages();

2. 实现方法UserServiceImpl

       public List<User> list(Integer page) {
           if(page==null){
               page=1;
           }
           //计算页面范围
           int size = 8;
           int start = (page-1)*size;
   
           //调用数据层处理业务
           return userDao.findAllUsers(start, size);
       }
       public int listPages() {
           int rows = userDao.countUsers();
           int size = 8;
           int pages = rows/size;
           if(rows%size==0){
               return pages;
           }
           return pages+1;
       }

3. 测试
       @Test
       public void testList(){
           List<User> list=service.list(null);
           for (User user : list) {
               System.out.println(user);
           }
       }
   
       @Test
       public void testListPages(){
           int n = service.listPages();
           System.out.println(n);
       }

3.重构控制器

1. 重构控制器
       @RequestMapping("/users.do")
       public String users(ModelMap map,@RequestParam(required=false, value="page") Integer page){
           //访问业务层获取全部用户信息
           List<User> list=userService.list(page);
           int pages = userService.listPages();
           map.put("users", list);
           map.put("pages", pages);
           //System.out.println(list);
           //转发到JSP页面，显示结果
           return "user/list";
       }

2. JSP页面重用即可
3. 测试...

---

实现添加用户功能

原理：

 

1.显示添加界面

1. 在控制器中添加方法，显示添加页面

   /**
   * 在控制器中添加方法，显示添加页面
   */
   @RequestMapping("/add.do")
   public String add(){
   return "user/add";
   }

2. 测试

2.实现保存功能

1. 添加DAO方法

   int insertUser(User user);

2. 添加SQL

   <insert id="insertUser"
           parameterType="cn.tedu.store.bean.User"
           useGeneratedKeys="true"
           keyProperty="id">
       insert into user(
           id,
           username,
           password,
           mobile,
           email,
           create_time
       ) values(
           null,
           #{username},
           #{password},
           #{mobile},
           #{email},
           #{createTime}
       )
   </insert>

3. 测试

       @Test
       public void testInsertUser(){
           User user=new User(null, "Andy",
                   "123", "119", "110@tom.com", new Date());
           int n = dao.insertUser(user);
           System.out.println(n);
       }
   

3.业务层

1. 添加业务层方法
   User save(String usernane, String password,
   String mobile, String email);

2. 实现业务层方法

       public User save(String username,
                        String password, String mobile,
                        String email) {
           User user=new User(null,
                   username, password, mobile,
                   email, new Date());
           int n = userDao.insertUser(user);
           if(n!=1){
               throw new RuntimeException("添加失败！");
           }
           return user;
       }

3. 测试

       @Test
       public void testSave(){
           User user=service.save("Wang",
                   "123", "12345678", "wang@tom.com");
           System.out.println(user);
       }

4.控制器

1. 添加控制器方法

       @RequestMapping("/save.do")
       public String save(String username,
                          String password, String mobile,
                          String email) {
           User user = userService.save(
                   username, password, mobile, email);
           return "redirect:users.do";
       }

2. 测试

---

作业

1. 利用SSM实现用户信息的管理。

---

作者：Darren

QQ：603026148

以上内容归靳烨所有，如果有什么错误或者不足的地方请联系我，希望我们共同进步。

---