菜鸡学习SSM整合

SSM整合

ssm整合说明

（1）SSM是什么？
Spring,SpringMVC,Mybastis
（2）为什么要专门训练SSM
要开发一个项目，首先是搭建SSM环境，之后才能开发其他功能
（3）整合思路是什么？
》》1.先搭建整合的环境
》》2.先把Spring的配置搭建完成
》》3.再使用Spring整合SpringMVC框架
》》4.最后使用Spring整合MyBatis框架
（4）SSM整合可以使用多种方式，咱们会选择XML + 注解的方式

搭建SSM环境

1.准备一个ssm数据库，并创建person表用于测试
CREATE DATEBASE ssm;
USE ssm;
SET FOREIGN_KEY_CHECKS=0;
DROP TABLE IF EXISTS person;
CREATE TABLE person (
id int(11) NOT NULL AUTO_INCREMENT,
name varchar(20) DEFAULT NULL,
money double DEFAULT NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

INSERT INTO person VALUES (‘1’, ‘striveday’, ‘10000’);
INSERT INTO person VALUES (‘2’, ‘studyday’, ‘20000’);

2.pom.xml导入依赖

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<spring.version>5.2.9.RELEASE</spring.version>
<slf4j.version>1.6.6</slf4j.version>
<log4j.version>1.2.12</log4j.version>
<mysql.version>5.1.6</mysql.version>
<mybatis.version>3.4.5</mybatis.version>

org.aspectj aspectjweaver 1.6.8

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</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-web</artifactId>
  <version>${spring.version}</version>
</dependency>

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>${spring.version}</version>
</dependency>

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</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-jdbc</artifactId>
  <version>${spring.version}</version>
</dependency>

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
</dependency>

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>${mysql.version}</version>
</dependency>

<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>servlet-api</artifactId>
  <version>2.5</version>
  <scope>provided</scope>
</dependency>

<dependency>
  <groupId>javax.servlet.jsp</groupId>
  <artifactId>jsp-api</artifactId>
  <version>2.0</version>
  <scope>provided</scope>
</dependency>

<dependency>
  <groupId>jstl</groupId>
  <artifactId>jstl</artifactId>
  <version>1.2</version>
</dependency>

<!-- log start -->
<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>${log4j.version}</version>
</dependency>

<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>${slf4j.version}</version>
</dependency>

<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
  <version>${slf4j.version}</version>
</dependency>

<!-- log end -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>${mybatis.version}</version>
</dependency>

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>1.3.0</version>
</dependency>

<dependency>
  <groupId>c3p0</groupId>
  <artifactId>c3p0</artifactId>
  <version>0.9.1.2</version>
  <type>jar</type>
  <scope>compile</scope>
</dependency>

3.配置log4j日志属性文件log4j.properties

Spring配置测试IOC和DI

1.创建测试类，测试控制反转和依赖注入，测试方法调用

//用spring自带的test测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(“classpath:applicationContext.xml”)
public class TestPersonService {
//日志
private static final Logger log = Logger.getLogger(TestPersonService.class.getName());
//自动装载
@Autowired
IPersonService personService;

//测试IOC DI依赖注入是否成功
@Testz
public void test01(){
    System.out.println(personService);
}

//测试查询方法
@Test
public void test02(){
    //记录日志
    log.info(personService+"");
    //查询所有
    List<Person> list = personService.findAll();
    //调用保存
    log.info("allPerson："+list+"");
}

//测试增加方法
@Test
public void test03(){
    Person person = new Person(null,"striveday",20000000.68);
    personService.savePerson(person);

    List<Person> list = personService.findAll();
    log.info("allPerson："+list+"");
}

}

2.创建javabean对象person
public class Person {
private Integer id;
private String name;
private Double money;
//省略get/set方法
}

3.创建测试业务接口IPersonService及其实现类PersonServiceImpl
public interface IPersonService {
//查找所有person
List findAll();
//新增一个person
int savePerson(Person person);
}

@Service
public class PersonServiceImpl implements IPersonService {

@Autowired
private IPersonDao personDao;

@Override
public List<Person> findAll() {
    List<Person> allPersonList = personDao.findAll();
    return allPersonList;
}

@Override
public int savePerson(Person person) {
    int code = personDao.savePerson(person);
    return code;
}

}

4.创建dao层接口IPersonDao及其实现类PersonDaoImpl，因为没有整合MyBatis，所以就不进行xml映射配置，所以这里用PersonDaoImpl实现类
public interface IPersonDao {
//查询所有用户
List findAll();
//新增一个person
int savePerson(Person person);
}

@Repository
public class PersonDaoImpl implements IPersonDao {
@Override
public List findAll() {
System.out.println(“findAll”);
//因为没有整合mybatis，这里设置初始化数据进行模拟
List personList = null;
personList.add(new Person(null,“studyday”,10000.0));
personList.add(new Person(null,“striveday”,20000.0));
return personList;
}

@Override
public int savePerson(Person person) {
    System.out.println("savePerson");
    return 1;
}

}

5.配置spring核心配置文件applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>

<!--   设置扫描包，包下设置注解@Service @Repository @Component @AutoWried-->
<context:component-scan base-package="com.xgf">
    <!--    由于springmvc的controller是由springmvc来扫描，需要将controller排除在外-->
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

6.测试IOC（DI）是否可以注入，测试方法是否可以执行

Spring整合SpringMVC框架1

1.web.xml中配置前端控制器DispatcherServlet
SpringMVC的核心就是DispatcherServlet，DispatcherServlet实质也是一个HttpServlet。DispatcherSevlet负责将请求分发，所有的请求都有经过它来统一分发。
2.web.xml中配置编码过滤器CharacterEncodingFilter
在 SpringMVC 中，框架直接给我们提供了一个用来解决请求和响应的乱码问题的过滤器 CharacterEncodingFilter
3.web.xml中配置编码监听器ContextLoaderListener
web.xml中的配置文件中ContextLoaderListener作为监听器，会监听web容器相关事件，在web容器启动或者关闭时触发执行响应程序
web.xml 配置DispatcherServlet，CharacterEncodingFilter,ContextLoaderListener

contextConfigLocation classpath:applicationContext.xml characterEncodingFilter org.springframework.web.filter.CharacterEncodingFilter encoding UTF-8 characterEncodingFilter /* org.springframework.web.context.ContextLoaderListener dispatcherServlet org.springframework.web.servlet.DispatcherServlet contextConfigLocation classpath:springmvc.xml 1 dispatcherServlet /

Spring整合SpringMVC的框架2

1.springmvc中配置视图解析器，组件扫描，注解驱动
2.配置springmvc对资源文件的放行
3.编写一个PersonController测试
4.编写一个list.jsp页面进行展示数据
配置springmvc.xml

<?xml version="1.0" encoding="UTF-8"?>

<context:component-scan base-package=“com.wzx”>

<context:include-filter type=“annotation” expression=“org.springframework.stereotype.Controller”/>
</context:component-scan>

<!--配置的视图解析器对象 /WEB-INF/pages/success.jsp -->
<bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/pages/"/>
    <property name="suffix" value=".jsp"/>
</bean>
<!--过滤静态资源   .js .css png-->
<mvc:resources location="/css/" mapping="/css/**" />
<mvc:resources location="/images/" mapping="/images/**" />
<mvc:resources location="/js/" mapping="/js/**" />
<!--开启SpringMVC注解的支持 @RequestMapping @RequestBody @ResponseBody-->
<mvc:annotation-driven/>

PersonController
@Controller
@RequestMapping("/person")
public class PersonController {
@Autowired
private IPersonService personService;

@RequestMapping(path="/list",method = RequestMethod.GET)
public String list(Model model){
    //显示所有的person数据
    List<Person> list = personService.findAll();
    System.out.println("list() list= "+list);
    //数据放在Model对象，由Model传给页面
    model.addAttribute("list",list);//参1 key  参2 value
    return "list";
}

}

list.jsp
<%@ page contentType=“text/html;charset=UTF-8” language=“java” isELIgnored=“false” %>
<%@ taglib prefix=“c” uri=“http://java.sun.com/jsp/jstl/core” %>

${person.id}

${person.name}

${person.money}

Service由于有junit测试基本不会有bug
Web层 使用log4j 打印 请求参数，响应给页面的数据

Spring整合Mybatis 配置Mybatis

1.SqlMapConfig.xml
》》指定四大信息：账号密码ip端口
》》指定domain别名
》》指定映射文件
2.编写测试
》》保存
》》查询
SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8"?>

TestMyBatis
public class TestMyBatis {
private SqlSession session;
@Before
public void init(){
// 加载配置文件
InputStream in = TestMyBatis.class.getClassLoader().getResourceAsStream(“SqlMapConfig.xml”);
// 创建SqlSessionFactory对象
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
// 创建SqlSession对象
session = factory.openSession();
}
@After
public void destory(){
session.commit();
session.close();
}
@Test
public void test01(){
//最核心对象是session
// System.out.println(session);
//Mybastis的特点是sql与代码是分开的，需要映射文件
IPersonDao dao = session.getMapper(IPersonDao.class);
List list = dao.findAll();
System.out.println(list);
}
@Test
public void test02(){
//最核心对象是session

    IPersonDao dao =  session.getMapper(IPersonDao.class);
    dao.save(new Person("tony",200.00));

}

}

IPersonDao.xml

<?xml version="1.0" encoding="UTF-8" ?> select * from person;

<insert id="save" parameterType="person">
    insert into person (name,money)values(#{name},#{money})
</insert>

4.测试MyBatis环境，执行测试方法
测试test01查询所有person

测试test02增加person

Spring整合MyBatis，配置数据库连接池c3p0，整合mybatis核心配置到spring核心配置文件中

1.Spring整合MyBatis需要一个整合包mybatis-spring

org.mybatis
mybatis-spring
1.3.0

2.创建数据库连接的属性文件c3p0.properties

3.在applicationContext.xml中配置c3p0数据库连接池
  将MyBatis核心配置文件 SqlMapConfig 都整入Spring核心配置文件applicationContext.xml 中，交给Spring来管理。

<?xml version="1.0" encoding="UTF-8"?>

<!-- 引入c3p0的属性文件(里面是连接数据库四大信息键值对)，在配置中通过占位使用 -->
<context:property-placeholder location="classpath:c3p0.properties" />

<!-- 连接数据库的四大基本信息-->
<!-- 数据库连接池c3p0 -->
<!-- 用c3p0数据源配置连接池，里面有连接池  ComboPooledDataSource数据库连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <!-- 连接池4大组件 -->
    <property name="driverClass" value="${c3p0.driverClass}"/>
    <property name="jdbcUrl" value="${c3p0.jdbcUrl}"/>
    <property name="user" value="${c3p0.user}"/>
    <property name="password" value="${c3p0.password}"/>

    <!--初始化连接数  取值要在minPoolSize和maxPoolSize之间（可包含，闭区间） 默认值：3 -->
    <property name="initialPoolSize" value="${c3p0.initialPoolSize}"/>
    <!-- 最大连接数 （连接池中的连接数不能超过maxPoolSize最大连接数） 默认值：15-->
    <property name="maxPoolSize" value="${c3p0.maxPoolSize}"/>
    <!--最小连接数  默认值：3  -->
    <property name="minPoolSize" value="${c3p0.minPoolSize}"/>
    <!-- c3p0连接池中数据连接不够时（无空闲连接可用）,一次增长的个数（增长不能超过maxPoolSize最大连接个数） 默认值：3 -->
    <property name="acquireIncrement" value="${c3p0.acquireIncrement}"/>
    <!-- 连接的最大空闲时间，如果超过这个时间还没有被使用，就断开这个连接（设置为0或负数，就永远都不会被断开） 单位：秒  默认值 ：0 -->
    <property name="maxIdleTime" value="${c3p0.maxIdleTime}"/>

    <!-- 从数据库获取新连接失败后重复尝试的次数。小于等于0表示无限次  默认值: 30-->
    <property name="acquireRetryAttempts" value="${c3p0.acquireRetryAttempts}"/>
    <!-- 两次连接的中间间隔时间（重新尝试的时间间隔）  单位：毫秒  默认值：1000 -->
    <property name="acquireRetryDelay" value="${c3p0.acquireRetryDelay}"/>
    <!-- 连接关闭时，是否将所有未提交的操作进行事务回滚  默认值：false -->
    <property name="autoCommitOnClose" value="${c3p0.autoCommitOnClose}"/>
    <!-- 当连接池用完时,客户端调用getConnection()后等待获取新连接的时间  单位：毫秒  默认值：0
            如果值设为 0，将无限期等待，直到有空闲连接。  否则按照设置的值，超时将抛出SQLException异常
            时间设置过小时会出现连接超时，这样会抛出SQLException异常，设置时间时需要小心，按照实际情况设置适当的值-->
    <property name="checkoutTimeout" value="${c3p0.checkoutTimeout}"/>
    <!-- 每隔多少秒检查所有连接池中的空闲连接  单位：秒   默认值：0 -->
    <property name="idleConnectionTestPeriod" value="${c3p0.idleConnectionTestPeriod}"/>

    <!-- 配置PreparedStatement缓存，设置连接池为数据源缓存的PreparedStatement的总数
            为0的时候不缓存，同时maxStatementsPerConnection的配置无效。
           由于PreparedStatement属于单个Connection,所以这个数量应该根据应用中平均连接数乘以每个连接的平均PreparedStatement来计算-->
    <property name="maxStatements" value="${c3p0.maxStatements}"/>

</bean>

<!--   设置扫描包，包下设置注解@Service @Repository @Component @AutoWried-->
<context:component-scan base-package="com.xgf">
    <!--    由于springmvc的controller是由springmvc来扫描，需要将controller排除在外-->
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

4.在applicationContext.xml中配置session工厂和编译后dao目录文件扫描

5.测试配置c3p0数据源能否拿到连接，并测试查询和新增
//测试c3p0数据库连接池，数据源是否配置对，能否拿到连接
//测试查询person、增加person
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(“classpath:applicationContext.xml”)
public class TestC3p0DataSource {
private static final Logger log = Logger.getLogger(TestC3p0DataSource.class.getName());

@Autowired
DataSource dataSource;
//测试能否通过链接拿到数据
@Test
public void testDataSource() throws SQLException {
    log.info("testDataSource获取连接："+dataSource.getConnection());
}

@Autowired
IPersonDao personDao;

//测试查询
@Test
public void test01(){
    List<Person> personList = personDao.findAll();
    System.out.println(personList);
}
//测试新增
@Test
public void test02(){
    Person person =  new Person(null,"TestC3p0DataSource",200.00);
    personDao.savePerson(person);
}

}

测试testDataSource()，看能否从c3p0拿到连接


测试配置c3p0数据库连接池之后对数据库操作：


6.Spring整合MyBatis，配置事务管理，让Spring来管理事务
  spring事务的底层是AOP，做一个转账功能或者批量保存功能来验证是否能满足条件（一个事务必须全部执行或者全部不执行，查看错误是否发生事务回滚就行）
  这里通过批量增加person，出现除零(1/0)错误，查看是否事务回滚。
 
applicationContext.xml配置事务管理

<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!-- spring提供的tx标签对方法进行分类 -->
    <tx:attributes>
        <!-- 方法：所有以find开头的都不进行事务管理（以后查询都以find开头） -->
        <tx:method name="find*" read-only="true"/>
        <!-- 其他的都用默认的DEFAULT，进行事务管理
                （DEFAULT是默认的事务隔离级别，mysql用什么事务隔离级别我们也用） -->
        <tx:method name="delete*" isolation="DEFAULT"/>
        <tx:method name="save*" isolation="DEFAULT"/>
        <tx:method name="update*" isolation="DEFAULT"/>
    </tx:attributes>
</tx:advice>

<!-- 配置AOP实现增强，配置aop事务 -->
<aop:config>
    <!-- expression表达式的值，按照你的路径配置
        * com.xgf.service.impl.*ServiceImpl.*(..))
            第一个* 是返回值通配符
            然后是包的路径，*ServiceImpl表示配置的所有满足类名+ServiceImpl后缀的且在com.xgf.service.impl目录下的
            *(..) ： *表示所有方法 (..)表示匹配所有参数
    -->
    <aop:pointcut id="service" expression="execution(* com.xgf.service.impl.*ServiceImpl.*(..))"/>
    <!-- 切入点 一个增强通知以及一个说明在何处增强的切入点  -->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="service"/>
</aop:config>

dao、service和serviceImpl写savePersonList保存多个person

IPersonDao
@Repository
public interface IPersonDao {
//保存多个person
int savePersonList(List personList);
}

IPersonService
public interface IPersonService {
//增加多个person
int savePersonList(List personList);
}

@Service
public class PersonServiceImpl implements IPersonService {

@Autowired
private IPersonDao personDao;

@Override
public int savePersonList(List<Person> personList) {
    int code = personDao.savePersonList(personList);
    return code;
}

}

7.映射文件IPersonDao.xml插入多个person

<!-- 使用foreach元素，插入多条用户信息 -->
<!-- 插入一条：insert into person (name,money)values(#{name},#{money})
        这里接收的参数是personList，参数类型是java.util.List
        循环遍历要用 collection="list"
 -->
<insert id="savePersonList" parameterType="java.util.List">

    insert into person(name,money)values
    <foreach item="item" index="index" separator="," collection="list">
        (#{item.name},#{item.money})
    </foreach>
</insert>

8.测试

正常测试，没有1/0错误代码
//模拟看是否发生事务回滚 批量保存（保存的过程中有一个地方抛出异常，就应该全部回滚）
@Test
public void test04(){
List personList = new ArrayList<>();
personList.add(new Person(null,“savePerson_001”,100.00));
personList.add(new Person(null,“savePerson_002”,200.00));
personList.add(new Person(null,“savePerson_003”,300.00));

    int code = personService.savePersonList(personList);
    log.info("插入" + code + "条person数据");
}

有异常抛出（1/0） by zero异常，看事务是否回滚
//模拟看是否发生事务回滚 批量保存（保存的过程中有一个地方抛出异常，就应该全部回滚）
@Test
public void test04(){
List personList = new ArrayList<>();
personList.add(new Person(null,“savePerson_001”,100.00));
personList.add(new Person(null,“savePerson_002”,200.00));
//抛出1/0异常
System.out.println(1/0);
personList.add(new Person(null,“savePerson_003”,300.00));

    int code = personService.savePersonList(personList);
    log.info("插入" + code + "条person数据");
}