天天看点
返回

SSM框架整合（一）：SSM环境的搭建

写在前面

在学习完了MyBatis、Spring、SpringMVC之后，现在进行SSM的整合，写一个简单的项目

整体项目结构，因为图片上传好像出了点问题，目录如下

-src
	-main
		-java
			-com.michilay
				-controller
					BooksController(java)
				-dao
					BooksMapper(interface)
				-pojo
					Books(java)
				-service
					BooksService(interface)
					BooksServiceImpl(java)
		-resources
			-com.mihcilay.dao
				BooksMapper.xml
			applicationContext.xml
			jdbc.properties
			rebel.xml
			spring-dao.xml
			spring-mvc.xml
			spring-service.xml
-web
	-WEB-INF
		-jsp
			test.jsp
		web.xml
	index.jsp
pom.xml

数据库准备 

CREATE TABLE books (
	bookID int(10) not null auto_increment comment '书id',
	bookName varchar(100) not null comment '书名',
	bookCounts int(11) not null comment '数量',
	detail varchar(200) not null comment '描述',
	key bookID (bookID)
)		engine=innodb default charset=utf8

INSERT INTO `books` VALUES (1, 'java', 1, '从入门到放弃');
INSERT INTO `books` VALUES (2, 'MySQL', 10, '从删库到跑路');
INSERT INTO `books` VALUES (3, 'Linux', 4, '从进门到进牢');

创建项目

创建一个普通的Maven项目， 导入以下依赖

<dependencies>
<!--        数据库连接-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>
<!--        单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
<!--        servlet-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
            <scope>provided</scope>
        </dependency>
<!--        Mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>
<!--        spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.9</version>
        </dependency>
<!--        简化代码-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.5</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
         <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.7</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>

idea连接数据库（这一步可省略，只是为了方便

MyBatis层

相关配置文件

mybatis-config配置文件如下

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--    导入外部的资源文件-->
    <properties resource="jdbc.properties"/>

    <typeAliases>
        <package name="com.michilay.dao"/>
    </typeAliases>

    <!--    配置数据库的环境-->
    <environments default="mysql">
        <environment id="mysql">
            <!--            使用jdbc数据管理-->
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!--    导入映射文件-->
    <mappers>
        <package name="com.michilay.dao"/>
    </mappers>

</configuration>

jdbc.properties配置自己的数据库

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC&characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456

实体类和接口方法方法

Books实体类

package com.michilay.pojo;


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Books {
    private int bookID;
    private String bookName;
    private int bookCounts;
    private String detail;
}

BooksMapper持久层操作接口

package com.michilay.dao;

import com.michilay.pojo.Books;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface BooksMapper {
//    增加一本书
    int addBook(Books books);
//    删除一本书
    int deleteBookById(@Param("bookID") int id);
//    更新一本书
    int updateBook(Books books);
//    查找
    Books findBookById(@Param("bookID") int id);
    List<Books> findAllBook();
}

BooksMapper实现方法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.michilay.dao.BooksMapper">

    <insert id="addBook" parameterType="Books">
        insert into books (bookName, bookCounts, detail)
         value (#{bookName},#{bookCounts},#{detail})
    </insert>
    
    <delete id="deleteBookById" parameterType="int">
        delete from books where bookID = #{bookID}
    </delete>

    <update id="updateBook" parameterType="Books">
        update books
        <set>
            <if test="bookName != null">
                bookName = #{bookName}
            </if>
            <if test="bookCounts != 0">
                bookCounts = #{bookCounts}
            </if>
            <if test="detail != null">
                detail = #{detail}
            </if>
        </set>
        
        where bookID = #{bookID}
    </update>
    
    <select id="findBookById" resultType="Books">
        select * from books where bookID = #{bookID}
    </select>

    <select id="findAllBook" resultType="Books">
        select * from books
    </select>
</mapper>
注意：这里创建包的时候，和java不同，java中创建的包是com.michilay.dao，但是resources文件夹下创建包应该写成com/michilay/dao，包括后面创建web下的目录也是要用/

测试类 

import com.michilay.dao.BooksMapper;
import com.michilay.pojo.Books;
import lombok.SneakyThrows;
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.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MyBatisTest {
    static SqlSession ss = null;
    static BooksMapper getMapper(){
        InputStream resourceAsStream = null;
        try {
            resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsStream);
        ss = build.openSession();
        BooksMapper mapper = ss.getMapper(BooksMapper.class);
        return mapper;
    }
    @SneakyThrows
    @Test
    public void testFindAll(){
        BooksMapper mapper = MyBatisTest.getMapper();
        List<Books> allBook = mapper.findAllBook();
        for (Books books : allBook) {
            System.out.println(books);
        }
    }
    @SneakyThrows
    @Test
    public void testFindById(){
        BooksMapper mapper = MyBatisTest.getMapper();
        Books bookById = mapper.findBookById(1);
        System.out.println(bookById);
    }
    @Test
    public void testAdd(){
        BooksMapper mapper = MyBatisTest.getMapper();
        Books books1 = new Books(4, "测试书本4",14,"测试细节4");
        mapper.addBook(books1);
        ss.commit();
        ss.close();
        testFindAll();
    }
    @Test
    public void testDelete(){
        BooksMapper mapper = MyBatisTest.getMapper();
        mapper.deleteBookById(4);
        ss.commit();
        ss.close();
        testFindAll();
    }
    @Test
    public void testUpdate(){
        BooksMapper mapper = MyBatisTest.getMapper();
        Books books = new Books();
        books.setBookID(6);
        books.setDetail("更改后的详情");
        mapper.updateBook(books);
        ss.commit();
        ss.close();
        testFindAll();
    }

}

测试没有问题后进入下一阶段

Spring层

将mybatis配置引入到spring中，spring-dao.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           https://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           https://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/mvc
           https://www.springframework.org/schema/mvc/spring-mvc.xsd
           http://www.springframework.org/schema/aop
           https://www.springframework.org/schema/aop/spring-aop.xsd">
        <context:component-scan base-package="com.michilay.dao"/>
<!--    关联配置文件-->
        <context:property-placeholder location="classpath:jdbc.properties"/>
<!--    链接池，dbcp（半自动化操作，手动连接），c3p0（自动化操作，自动化加载配置文集，自动设置到对象
        druid，hikari-->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="driverClassName" value="${jdbc.driver}"/>
            <property name="url" value="${jdbc.url}"/>
            <property name="username" value="${jdbc.username}"/>
            <property name="password" value="${jdbc.password}"/>
        </bean>

        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource"/>

            <property name="typeAliasesPackage" value="com.michilay.pojo"/>

            <property name="mapperLocations" value="classpath:com/michilay/dao/*.xml"/>
        </bean>

<!--        配置dao接口扫描包,动态实现dao接口自动注入-->
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!--            要扫描的dao包-->
            <property name="basePackage" value="com.michilay.dao"/>
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        </bean>
</beans>

Spring和服务层的整合配置文件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:aop="http://www.springframework.org/schema/aop"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           https://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           https://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/tx
           https://www.springframework.org/schema/tx/spring-tx.xsd
           http://www.springframework.org/schema/aop
           https://www.springframework.org/schema/aop/spring-aop.xsd">


<!--        扫描包-->
    <context:component-scan base-package="com.michilay.service"/>

<!--        声明式事务-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--        注入数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
<!--        aop事务支持-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut id="txPointCut" expression="execution(* com.michilay.dao.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>
</beans>

总配置文件applicationContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           https://www.springframework.org/schema/beans/spring-beans.xsd">


        <import resource="classpath:spring-dao.xml"/>
        <import resource="classpath:spring-service.xml"/>
    	

</beans>

service层 

package com.michilay.service;

import com.michilay.pojo.Books;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Service;

import java.util.List;



public interface BooksService {
    //    增加一本书
    int addBook(Books books);
    //    删除一本书
    int deleteBookById(int id);
    //    更新一本书
    int updateBook(Books books);
    //    查找
    Books findBookById(int id);
    List<Books> findAllBook();
}
           
package com.michilay.service;

import com.michilay.dao.BooksMapper;
import com.michilay.pojo.Books;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
@Service("booksService")
public class BooksServiceImpl implements BooksService{
        
    private BooksMapper booksMapper;
    
    @Autowired
    public void setBooksMapper(BooksMapper booksMapper) {
        this.booksMapper = booksMapper;
    }

    @Override
    public int addBook(Books books) {
        return booksMapper.addBook(books);
    }

    @Override
    public int deleteBookById(int id) {
        return booksMapper.deleteBookById(id);
    }

    @Override
    public int updateBook(Books books) {
        return booksMapper.updateBook(books);
    }

    @Override
    public Books findBookById(int id) {
        return booksMapper.findBookById(id);
    }

    @Override
    public List<Books> findAllBook() {
        return booksMapper.findAllBook();
    }
}

加上注解

在BooksMapper前加上@Repository

测试类 

import com.michilay.dao.BooksMapper;
import com.michilay.pojo.Books;
import com.michilay.service.BooksService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest {

    @Autowired
    public BooksService booksService;
    @Test
    public void test1() throws Exception{
        List<Books> allBook = booksService.findAllBook();
        for (Books books : allBook) {
            System.out.println(books);
        }
    }
    @Test
    public void test2(){
        ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        BooksMapper bean = classPathXmlApplicationContext.getBean("booksMapper", BooksMapper.class);
        List<Books> allBook = bean.findAllBook();
        for (Books books : allBook) {
            System.out.println(books);
        }
    }
}

一个是对spring的测试，一个是对spring整合mybatis的测试，通过后进入下一步

SpringMVC层

给项目添加WEB框架支持

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>
</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
           https://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           https://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/mvc
           https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--    自动扫描包-->
    <context:component-scan base-package="com.michilay.controller"/>
    <!--    让spring mvc不处理静态的数据-->
    <mvc:default-servlet-handler/>
    <!--    代替了HandlerMapping和HandlerAdapter,自动开启自动注入-->
    <mvc:annotation-driven/>

    <!--视图解析器：DispatcherServlet给他的ModelAndView-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!--        转发的前缀合后缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

记得要在总配置文件applicationContext中加上

配置环境

  1. 在项目结构中，新建lib，导入所有的jar包
  2. 在Tomcat中配置Tomcat 8.5，并且更改路径
  3. 将项目的Jrebel打上勾（可省略，热部署用的插件，提高效率）

编写Conroller进行测试 

package com.michilay.controller;

import com.michilay.pojo.Books;
import com.michilay.service.BooksService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

@Controller
public class BooksController {

    @Autowired
    private BooksService booksService;

    @RequestMapping("/t1")
    public String test1(Model model){
        model.addAttribute("msg","SpringMvc层测试通过");
        return "test";
    }

    @RequestMapping("/t2")
    public String list(Model model){
        List<Books> allBook = booksService.findAllBook();
        model.addAttribute("msg",allBook);
        return "test";
    }

}

测试完成就表示整合好了，前端可以从数据库拿到数据显示了，实现了ssm框架，下面就是进一步的优化了

写在后面

整合过程中会遇到很多的问题，这不是坏事，对这些问题，一步一步的排查，总会找到问题所在的

在写完这边文章后，我又从头按照自己的教程重来了一遍，耗时两个小时，中间也出了不少错误，很多都是因为自己没看仔细造成的，不过还是觉得，在学完了ssm三大原理之后再进行整合的学习，是有效学习，出错也是一种学习，因为我知道他错误在哪个环节。

ssm spring mybatis SpringMVC java
上一篇: 用 Python 连接 MySQL 的几种方式详解
下一篇: ssm框架整合，ssm框架环境搭建

继续阅读