spring+springmvc+mybatis整合

一、开发环境：

1.编译工具：STS（spring tool suite）这个对spring项目支持比较好。

2.项目管理工具：maven，主要用来管理一些jar包，解放你的双手，不用一个一个去下载jar包进行粘贴。

3.jdk版本：1.8

4.web服务器：jetty，内置服务器，方便测试

二、必备网站：

1.jar包仓库:https://mvnrepository.com/

2.spring官网：https://docs.spring.io/

spring core:https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html

spring mvc:https://docs.spring.io/spring/docs/current/spring-framework-reference/web.html

3.mybatis官网:http://www.mybatis.org/mybatis-3/zh/index.html

三、开始配置：

先分享一下我的学习心得：

框架整合难不难？难！东西多，配置文件复杂不好记忆！！！

曾经听人说过spring的配置是灾难级别的，xml文件编写特别痛苦，漏一个地方基本就凉凉了，那怎么才能正确配置，按照哪种顺序来进行配置才是正确的呢？其实每个人配置的习惯都是不一样的，而且框架本身设计思想就是“即有自身默认规则，也可用户灵活配置”,你仔细看看的话，其实框架设计的时候基本都遵循这样一个规则。所以这就导致了菜鸟学习的时候比较痛苦，可能你是看视频学习的框架配置，跟着老师学习了一种配置套路 ，但是自己脱离视频自己配置的时候，直接挂，为什么，可能找了好久发现少了一个jar包，或者少一个注解，又或者xml文件bean没声明等等一系列奇葩的问题，为什么自己上机就傻了呢，最大的原因就是你根本不理解为什么要做这个配置，只是为了配置去配置。

怎么去解决这个问题呢？通过这一段的学习我找到了一个解决这个问题的方法，那就是有目的的去配置，有需求的去配置。通俗点说就是一个萝卜一个坑，我每写一行代码就要知道，他是干什么的能实现什么功能，只有做到“刨根问底”，才能在框架配置中做到得心应手，游刃有余。

想要配置spring+springmvc+mybatis这样的框架就要知道他们具体的用途，还有就是他们怎么整合，这里就不具体写了。

看完这个图是不是感觉清晰了许多，图是盗来的，但道理是真的。

这里再说一下mvc：为了能够让自己的项目通过浏览器访问，不然只能本机玩。

MVC:Model,View,Controller

1.Model:模型

（1）service:业务层，一个service会调用多个dao层的方法，更专注于处理业务（每个项目的业务都不一样）。

（2）dao层，用于做数据持久化（可以更换不同的存储方式）。

2.view:视图

(1)视图层，css,js,html这些都是view

3.Controller:控制器

(1)用于做控制器

 

有了这些知识之后我们开始进行配置：

第一步打开mybatis官网：

http://www.mybatis.org/mybatis-3/zh/getting-started.html

会看到一个快速入门：没错就是他，就能帮助你快速入门mybatis

既然没有固定的配置顺序，那我就从底层数据库开始，先跟我一起通过官网学习一下Mybatis

我们先提出第一个问题，通过问题驱动来学习：

1.怎么得到SqlSessionFactory?

我们知道：每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为中心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先定制的 Configuration 的实例构建出 SqlSessionFactory 的实例。

第一种构建SqlSessionFactory方式：从 XML 文件中构建 SqlSessionFactory 的实例非常简单，建议使用类路径下的资源文件进行配置。但是也可以使用任意的输入流(InputStream)实例，包括字符串形式的文件路径或者 file:// 的 URL 形式的文件路径来配置。MyBatis 包含一个名叫 Resources 的工具类，它包含一些实用方法，可使从 classpath 或其他位置加载资源文件更加容易。

实现代码：

String resource = "org/mybatis/example/mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

XML 配置文件（configuration XML）中包含了对 MyBatis 系统的核心设置，包含获取数据库连接实例的数据源（DataSource）和决定事务作用域和控制方式的事务管理器（TransactionManager）。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="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
      </dataSource>
    </environment>
  </environments>
  <mappers>
    <mapper resource="org/mybatis/example/BlogMapper.xml"/>
  </mappers>
</configuration>

当然，还有很多可以在XML 文件中进行配置，上面的示例指出的则是最关键的部分。要注意 XML 头部的声明，用来验证 XML 文档正确性。environment 元素体中包含了事务管理和连接池的配置。mappers 元素则是包含一组 mapper 映射器（这些 mapper 的 XML 文件包含了 SQL 代码和映射定义信息）。

既然有了 SqlSessionFactory ，顾名思义，我们就可以从中获得 SqlSession 的实例了。SqlSession 完全包含了面向数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。例如：

SqlSession session = sqlSessionFactory.openSession();
try {
  Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101);
} finally {
  session.close();
}

诚然这种方式能够正常工作，并且对于使用旧版本 MyBatis 的用户来说也比较熟悉，不过现在有了一种更直白的方式。使用对于给定语句能够合理描述参数和返回值的接口（比如说BlogMapper.class），你现在不但可以执行更清晰和类型安全的代码，而且还不用担心易错的字符串字面值以及强制类型转换。

例如：

SqlSession session = sqlSessionFactory.openSession();
try {
  BlogMapper mapper = session.getMapper(BlogMapper.class);
  Blog blog = mapper.selectBlog(101);
} finally {
  session.close();
}

其实上面说得两种得到mapper的方法就体现了框架的配置灵活性，老用户比较喜欢

“Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101);”这种方式，而现在比较流行的是

“BlogMapper mapper = session.getMapper(BlogMapper.class);Blog blog = mapper.selectBlog(101);”这样的，所以配置不能死记硬背，要理解性的去记忆，找到自己喜欢的方式去配置就好了，我比较倾向于第二种，这种看起来更清爽一些。

第二种构建SqlSessionFactory方式：

当然是不使用 XML 构建 SqlSessionFactory喽，xml文件看的我头皮发麻，所以我能不能用纯java来配置能，当然可以，大神已经在写mybatis的时候就帮你想好了，有需求，人家就有实现。

如果你更愿意直接从 Java 程序而不是 XML 文件中创建 configuration，或者创建你自己的 configuration 构建器，MyBatis 也提供了完整的配置类，提供所有和 XML 文件相同功能的配置项。

DataSource dataSource = BlogDataSourceFactory.getBlogDataSource();
TransactionFactory transactionFactory = new JdbcTransactionFactory();
Environment environment = new Environment("development", transactionFactory, dataSource);
Configuration configuration = new Configuration(environment);
configuration.addMapper(BlogMapper.class);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);

得到SqlSessionFactory ，顾名思义，我们就可以从中获得 SqlSession 的实例了，当然实现方法刚才上一种已经说过了，你可以选择老用户习惯的，也可以选择比较流行的，这里不再赘述。

现在提出第二个问题：

2.每次都通过读取mybatis的配置文件，来创建实例化对象，这样烦人不？举个例子，我一个项目创建个User对象，创建个manager对象，每次都要手动来创建这样岂不是要累死人，准确来说是累死程序猿？这能忍？你可能会说我比较菜，我忍了，但是大神们忍不了啊，那他们怎么来解决每次创建实例化对象这个繁琐的工作呢？

 

写spring的大神就搞了个容器，对mybatis开发者说：你把你的SqlSessionFactory 交给我，我来帮你管理，每次谁需要创建实例化对象，就让他来找我，我这个容器帮他自动创建。作为一个菜鸟已经惊呆了，还Tm有这种操作？LZ写那么多，你搞个容器就解决了？WTFK？

 

让我们来看看大神们是怎么实现的把，请托好你的下巴，别砸到了你的脚后跟上！！！

好的，让我们进入mybatis与spring整合的网页：http://www.mybatis.org/spring/zh/getting-started.html

没错，下面要进行的就是看教程！

先看一下，spring与mybatis整合第四章对事务这一块的讲解：

一个使用 MyBatis-Spring 的主要原因是它允许 MyBatis 参与到 Spring 的事务管理中。而 不是给 MyBatis 创建一个新的特定的事务管理器,MyBatis-Spring 利用了存在于 Spring 中的 DataSourceTransactionManager。

一旦 Spring 的 PlatformTransactionManager 配置好了,你可以在 Spring 中以你通常的做 法来配置事务。@Transactional 注解和 AOP(Aspect-Oriented Program,面向切面编程,译 者注)样式的配置都是支持的。在事务处理期间,一个单独的 SqlSession 对象将会被创建 和使用。当事务完成时,这个 session 会以合适的方式提交或回滚。！！

一旦事务创建之后,MyBatis-Spring 将会透明的管理事务。在你的 DAO 类中就不需要额 外的代码了。

标准配置

要 开 启 Spring 的 事 务 处 理 , 在 Spring 的 XML 配 置 文 件 中 简 单 创 建 一 个 DataSourceTransactionManager 对象:

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource" />
</bean>

指定的 DataSource 一般可以是你使用 Spring 的任意 JDBC DataSource。这包含了连接 池和通过 JNDI 查找获得的 DataSource。

要注意, 为事务管理器指定的 DataSource 必须和用来创建 SqlSessionFactoryBean 的 是同一个数据源,否则事务管理器就无法工作了。

没错就是这么简单，随便搞一个数据源DataSource，然后用上面这三行代码一配置，spring的事务处理就搞好了。举个例子：相当于mybatis现在已经把交接棒传给了spring。更形象一点：mybatis对spring说：大哥，数据库这一块已经被我摆平了，收的保护费（获取的数据）也交给你管理了。

这时候上面的第二个问题就不难理解了，spring通过控制反转来对mybatis进行管理，mybatis的实例化等过程都由spring容器类进行自动管理，这样就彻底解放了你的双手，spring帮你来搞定，这就是为什么要把spring与mybatis整合的原因。

现在提出第三个问题：

3.你要进行业务处理就要用到spring的事务管理机制，现在你用这个标准配置怎么进行声明式事务的管理呢？

好的下面让我们来看看spring官网上对声明式事务的介绍：https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#aop-introduction-defn

S：看不懂啊，什么东东？

T：什么？大点声？你再说一遍？

S：看不懂啊，全是洋码子

T：让你不好好学英语

书到用时方恨少，学英语时候不好好学，当你开始用到它的时候才发现，我要是英语好能省多大劲。不过没关系，毕竟在开源界还是有很多大神愿意分享自己的学习成果给我们的。像下面这样的：

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

而在AOP中，Aspect的含义，可能更多的理解为“切面”比较合适。

可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦,提高代码的灵活性和可扩展性，AOP可以说也是这种目标的一种实现。

在Spring中提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

主要功能

日志记录，性能统计，安全控制，事务处理，异常处理等等。

主要意图

将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

这里主要说一下声明式事务的配置：

<!-- 定义事务管理器 --> 
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
	<property name="dataSource" ref="myDataSource" /> 
	</bean> 
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	  <property name="dataSource" ref="myDataSource" />
	</bean>
	<tx:advice id="iccardTxAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="insert*" propagation="REQUIRED" read-only="false" rollback-for="java.lang.RuntimeException"/>
		</tx:attributes>
	</tx:advice>
	<aop:config>
		<aop:pointcut id="iccardTerm" expression="execution(*  com.xintoucloud.mybatis_spring.service..*.*(..))"/>
		<aop:advisor advice-ref="iccardTxAdvice" pointcut-ref="iccardTerm"/>
	</aop:config>  

 service层想要被调用，就需要实例化bean

<bean id="userService" class="com.xintoucloud.mybatis_spring.service.UserService">
		<property name="usermapper" ref="userMapper"></property>
	</bean> 

 要实例化bean就需要注入usermapper,注入有两种setter注入，或者构造注入，写下setter注入方式:

private UserMapper userMapper;
	public void setUserMapper(UserMapper userMapper) {
		this.userMapper = userMapper;
	}

 

在这里你可以指定事务边界，指定声明式事务在那一层有效，还可以指定service层不同的方法使用不同的事务传播。总之功能很强大，有需要上官网学习，这里不再详细介绍。

需要注意的就是，使用声明式事务，一定要记得加包，这是我原来走过的坑，在这里再说下，加深下印象。

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
	<dependency>
	    <groupId>org.aspectj</groupId>
	    <artifactId>aspectjweaver</artifactId>
	    <version>1.9.2</version>
	</dependency>

这样下来spring与mybatis就整合好了，你如果需要用junit可以先进行一些单元测试：

下面是我测试的一个小例子：需要注意的就是事务在出现异常时是否会发生回滚。

@Test
	public void testInsertUser1() {
		ApplicationContext ctx=new ClassPathXmlApplicationContext("springUser.xml");
		UserService userService= ctx.getBean(UserService.class);
		User user=new User();
		user.setUsername("mybatis110");
		user.setAddress("xinxiang");
		user.setUserpwd("123456");
		user.setPhoto("sdfdsfds");
		user.setEmail("qwewq@163.com");
		System.out.println("进入保存");
		userServiceImpl.insertUser(user);
		System.out.println("退出保存");
}

经过我的测试发现spring与mybatis整合成功了。这样基本上就够用了在本地玩。

下面就是第四个问题：

4.怎么让其他人通过网络访问我的项目？

需要部署到服务器中，当然就是加入spring mvc了！！

加入依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-webmvc</artifactId>
	    <version>5.1.2.RELEASE</version>
	</dependency>

我们通过依赖关系可以看到webmvc中已经包含了spring-aop,spring-web等众多jar包，所以你加jar包的时候，这些已经包含的完全可以不用加，不过加上了也没问题。

 

 

基本上配到这一步也都差不多了，下面展示一个我配置的项目

详细步骤如下：

第一步：创建一个maven项目，取名gsv(名字随便取的)

第二步，我们要用maven管理就要加入maven

在pom.xml中加入maven编译的插件，在这里我的jdk是1.8所以我就配置版本为1.8

<build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.0</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
     </plugins>
   </build>

我们把junit版本换成4.8.1

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

然后更新一下maven项目，你会发现你的已经变成了1.8

接下来整合开始了：

pom.xml文件中我加入的包完整版（带注释）

<!--mybatis-spring整合需要的文件  -->
	<dependency>
	    <groupId>org.mybatis</groupId>
	    <artifactId>mybatis-spring</artifactId>
	    <version>1.3.2</version>
	</dependency>
    <!-- mybatis整合需要的文件 -->
	<dependency>
	    <groupId>org.mybatis</groupId>
	    <artifactId>mybatis</artifactId>
	    <version>3.4.6</version>
	</dependency>
	<!-- mybatis日志文件 -->
	<dependency>
	    <groupId>log4j</groupId>
	    <artifactId>log4j</artifactId>
	    <version>1.2.17</version>
	</dependency>
	<!-- mysql-需要的文件 -->
	<dependency>
	    <groupId>mysql</groupId>
	    <artifactId>mysql-connector-java</artifactId>
	    <version>5.1.37</version>
	</dependency>
	<!-- spring相关的开始 -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-context</artifactId>
	    <version>5.1.2.RELEASE</version>
	</dependency>
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-tx</artifactId>
	    <version>5.1.3.RELEASE</version>
	</dependency>
	<dependency>
	    <groupId>org.aspectj</groupId>
	    <artifactId>aspectjweaver</artifactId>
	    <version>1.9.2</version>
	</dependency>
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-jdbc</artifactId>
	    <version>5.1.3.RELEASE</version>
	</dependency>
	<!-- spring相关的结束 -->
	<!-- https://mvnrepository.com/artifact/commons-dbcp/commons-dbcp -->
	<dependency>
	    <groupId>commons-dbcp</groupId>
	    <artifactId>commons-dbcp</artifactId>
	    <version>1.4</version>
	</dependency>
	<!-- spring与springmvc整合 -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-webmvc</artifactId>
	    <version>5.1.2.RELEASE</version>
	</dependency>
	<!-- 页面使用jsp所需要的开始 -->
	<dependency>
	    <groupId>javax.servlet</groupId>
	    <artifactId>jstl</artifactId>
	    <version>1.2</version>
	</dependency>
	<dependency>
	    <groupId>javax.servlet</groupId>
	    <artifactId>javax.servlet-api</artifactId>
	    <version>4.0.1</version>
	    <scope>provided</scope>
	</dependency>
	<!-- 页面使用jsp所需要的结束 -->
	<!-- 控制器层将返回值转换成json类型所需要的 -->
	<dependency>
	    <groupId>com.fasterxml.jackson.core</groupId>
	    <artifactId>jackson-databind</artifactId>
	    <version>2.9.7</version>
	</dependency>
	<!-- jsr验证需要的 -->
	<dependency>
	    <groupId>org.hibernate.validator</groupId>
	    <artifactId>hibernate-validator</artifactId>
	    <version>6.0.13.Final</version>
	</dependency>

因为我们要使用的是web项目，所以要把项目的打包类型改成war包：

因为web项目的目录要求，所以要建立这样的目录在src->main下建立，webapp->WEB-INF->web.xml

再更新一下自己的项目就好了。

然后开始放代码了啊：

这是整合ssm的完整目录，下面我就按照从上到下的顺序呢放代码了。

 UserController：

package com.xintoucloud.gsv.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import com.xintoucloud.gsv.entity.User;
import com.xintoucloud.gsv.service.UserService;

@Controller@RequestMapping("/user")
public class UserController {
	@Autowired
	private UserService userService;
	@RequestMapping("/list")
	public String list(Model m) {
		m.addAttribute("users", userService.list());
		return "list";
	}
	@RequestMapping("/delete")
	public String deleteUser(int id) {
		userService.deleteUser(id);	
		return "redirect:list";
		
	}
	@RequestMapping("/update")
	public String toUpdateUser(int id,Model m) {
		User user=userService.getUser(id);
		m.addAttribute("user", user);
		return "update";	
	}
	@PostMapping("/update")
	public String updateUser(User user) {
		userService.updateUser(user);
		return "redirect:list";
		
	}
	@RequestMapping("/add")
	public String toAddUser() {
		return "save";
	}
	@PostMapping("/add")
	public String AddUser(User user) {
		userService.insertUser(user);
		return "redirect:list";
	}

}

User：

package com.xintoucloud.gsv.entity;


public class User {
	private int uid;
	private String uname;
	private String upass;
	
	public int getUid() {
		return uid;
	}
	public void setUid(int uid) {
		this.uid = uid;
	}
	public String getUname() {
		return uname;
	}
	public void setUname(String uname) {
		this.uname = uname;
	}
	public String getUpass() {
		return upass;
	}
	public void setUpass(String upass) {
		this.upass = upass;
	}
	
}

UserMapper：

package com.xintoucloud.gsv.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import com.xintoucloud.gsv.entity.User;

public interface UserMapper {
	@Select("select * from t_user where uid=#{uid}")
	@Results({
		@Result(id= true ,column="uid",property="uid"),
		@Result(column="uname",property="uname"),
		@Result(column="upass",property="upass")
	})
	User getUser(int uid);
	@Select("select * from t_user")
	@Results({
		@Result(id= true ,column="uid",property="uid"),
		@Result(column="uname",property="uname"),
		@Result(column="upass",property="upass")
	})
	List<User> getUsers();
	@Insert("insert into t_user(uname,upass) values(#{uname},#{upass})")
	@Results({
		@Result(id= true ,column="uid",property="uid"),
		@Result(column="uname",property="uname"),
		@Result(column="upass",property="upass")
	})
	void insertUser(User user);
	@Update("update t_user set uid=#{uid},uname=#{uname},upass=#{upass} where uid=#{uid}")
	@Results({
		@Result(id= true ,column="uid",property="uid"),
		@Result(column="uname",property="uname"),
		@Result(column="upass",property="upass")
	})
	void updateUser(User user);
	@Delete("delete from t_user where uid=#{uid}")
	void deleteUser(int id);
}

UserService:

package com.xintoucloud.gsv.service;

import java.util.List;

import org.springframework.stereotype.Service;

import com.xintoucloud.gsv.entity.User;

@Service
public interface UserService {
	User getUser(int id);
	void insertUser(User user);
	List<User> list();
	void deleteUser(int id);
	void updateUser(User user);
}

UserServiceImpl:

package com.xintoucloud.gsv.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.xintoucloud.gsv.entity.User;
import com.xintoucloud.gsv.mapper.UserMapper;
import com.xintoucloud.gsv.service.UserService;

@Service@Transactional
public class UserServiceImpl implements UserService{
	@Autowired
	private UserMapper userMapper;
	
	@Override
	public User getUser(int id) {
		return userMapper.getUser(id);
	}
	@Override
	public void insertUser(User user) {
		userMapper.insertUser(user);
		//int i=1/0;
	}
	@Override
	public List<User> list() {
		return userMapper.getUsers();
	}
	@Override
	public void deleteUser(int id) {
		userMapper.deleteUser(id);
		//int i=1/0;
	}
	@Override
	public void updateUser(User user) {
		userMapper.updateUser(user);
		
	}
}

AppTest：不需要

UserTest:

package com.xintoucloud.gsv;

import java.util.List;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.xintoucloud.gsv.entity.User;
import com.xintoucloud.gsv.service.UserService;

public class UserTest {
	@Test
	public void testGetUser() {
		ApplicationContext ctx=new ClassPathXmlApplicationContext("spring-configure.xml");
        UserService userService= ctx.getBean(UserService.class); 
		User user=userService.getUser(1);
		System.out.println("username:"+user.getUname()+","+"upass:"+user.getUpass());
	}
	@Test
	public void testListUser() {
		ApplicationContext ctx=new ClassPathXmlApplicationContext("spring-configure.xml");
		UserService userService= ctx.getBean(UserService.class); 
		List<User> users=userService.list();
		for (User user2 : users) {
			System.out.println("username:"+user2.getUname()+","+"upass:"+user2.getUpass());
		}	
	}
	@Test
	public void testInsertUser() {
		ApplicationContext ctx=new ClassPathXmlApplicationContext("spring-configure.xml");
		UserService userService= ctx.getBean(UserService.class); 
		User user=new User();
		user.setUname("user4");
		user.setUpass("123456");
		userService.insertUser(user);
		
	}
	@Test
	public void testDeleteUser() {
		ApplicationContext ctx=new ClassPathXmlApplicationContext("spring-configure.xml");
		UserService userService= ctx.getBean(UserService.class); 
		userService.deleteUser(4);	
	}
	@Test
	public void testUpdateUser() {
		ApplicationContext ctx=new ClassPathXmlApplicationContext("spring-configure.xml");
		UserService userService= ctx.getBean(UserService.class); 
		User user=new User();
		user.setUid(3);
		user.setUname("user4");
		user.setUpass("123456");
		userService.updateUser(user);
	}
}

log4j.properties：

# Global logging configuration
log4j.rootLogger=bug, stdout
# MyBatis logging configuration...
log4j.logger.org.mybatis.example.BlogMapper=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

spring-configure.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:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	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.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
	<!-- Spring配置: 组件扫描(让Spring知道 哪些可以配置注解) -->
	<context:component-scan base-package="com.xintoucloud.gsv">  <!-- 组件扫描范围:mybatis_spring目录下 -->
		<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
	</context:component-scan>   <!-- 除了Controller(!类型!)的都进行组件扫描 -->
	<!--配置数据源，获取数据库连接  -->
	<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///gsv"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
        <property name="initialSize" value="5"></property>
        <property name="defaultAutoCommit" value="false"></property>
    </bean>
    <!-- 配置sessionFactory -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
	  <property name="dataSource" ref="myDataSource" />
	  <property name="mapperLocations" value="classpath*:com/xintoucloud/gsv/mapper/*.xml" />
	 <!--  <property name="typeAliases" value="com.xintoucloud.mybatis_spring.entity.User"></property> -->
	  <!--配置别名  -->
	  <property name="typeAliasesPackage" value="com.xintoucloud.mybatis_spring.entity"></property>
	</bean>
	<!--MapperFactoryBean 创建的代理类实现了 UserMapper 接口,并且注入到应用程序中 -->
	 <!--查 找 类 路 径 下 的 映 射 器 并 自 动 将 它 们 创 建 成 MapperFactoryBean  -->
	 <bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
	  <property name="mapperInterface" value="com.xintoucloud.gsv.mapper.UserMapper" />
	  <property name="sqlSessionFactory" ref="sqlSessionFactory" />
	</bean> 

	<!-- 配置声明式事务 -->
	 <!-- <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	  <property name="dataSource" ref="myDataSource" />
	</bean>
	<tx:advice id="iccardTxAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="insert*" propagation="REQUIRED" read-only="false" rollback-for="java.lang.RuntimeException"/>
		</tx:attributes>
	</tx:advice>
	<aop:config>
		<aop:pointcut id="iccardTerm" expression="execution(* com.xintoucloud.gsv.service..*.*(..))"/>
		<aop:advisor advice-ref="iccardTxAdvice" pointcut-ref="iccardTerm"/>
	</aop:config>  -->
	<!-- 定义事务管理器 --> 
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
	<property name="dataSource" ref="myDataSource" /> 
	</bean> 
	<!-- <bean id="userService" class="com.xintoucloud.mybatis_spring.service.UserService">
		<property name="usermapper" ref="userMapper"></property>
	</bean> -->
	<!-- 使用注释事务  -->
 	<tx:annotation-driven transaction-manager="transactionManager" /> 

</beans>

springmvc-configure.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:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
		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.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
	<!-- <context:component-scan base-package="com.xintoucloud.mybatis_spring"></context:component-scan> -->
	<!-- Spring配置: 组件扫描(让Spring知道 哪些可以配置注解)   -->
	<context:component-scan base-package="com.xintoucloud.gsv" use-default-filters="false">
		<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
	</context:component-scan>
	<!--支持jsp视图解析  -->
	<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
	    <property name="prefix" value="/WEB-INF/views/"/>
	    <property name="suffix" value=".jsp"/>
	</bean>
	<!-- 使用 验证规则 -->
	<bean id="validator" class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean"/> 
	<mvc:annotation-driven validator="validator"></mvc:annotation-driven>
	<!-- 静态资源配置 -->
	<mvc:default-servlet-handler />  
</beans>

list.jsp：

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
    <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>用户列表</title>
</head>
<body>
<table>
<tr>
<th>编号</th>
<th>用户名</th>
<th>密码</th>
</tr>
	<c:forEach items="${users }" var="user">
	<tr>
		<td>${user.uid }</td>
		<td>${user.uname }</td>
		<td>${user.upass }</td>
		<td><a href="delete?id=${user.uid }">删除</a> || <a href="update?id=${user.uid }">修改</a></td>
	</tr>
	</c:forEach>
	<tr><td colspan="7"><a href="add">添加新用户</a></tr>
</table>
</body>
</html>

save.jsp：

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
 <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>添加用户</title>
</head>
<body>
	<form method="post" action="add">
	用户名称:<input name="uname"/><br/>
	用户密码:<input type="password" name="upass"/><br/>
	<input type="submit" value="提交">
	</form>
</body>
</html>

update.jsp：

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
    <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>用户列表</title>
</head>
<body>
<table>
<form action="update" method="post">
<tr>
<th>>>></th>
<th>用户名</th>
<th>邮箱</th>
<th>地址</th>
</tr>
	<tr>
		<td><input type="hidden" name="uid" value="${user.uid }"></td>
		<td><input name="uname" value="${user.uname }"></td>
		<td><input name="upass" value="${user.upass }"></td>
		<td><input type="submit" value="提交"></td>
	</tr>
	</form>	
</table>
</body>
</html>

web.xml：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
 	<!--servletcontext监听器:读取spring实例化spring容器 （root WebApplicationContext 不可以访问servlet） -->
 	<listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
<!-- 上面监听器使用的上下文参数，指定spring配置文件的位置 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-configure.xml</param-value>
    </context-param>
    <!--配置前端控制器 ：接受所有请求，然后根据配置将请求分发给其他的业务控制器处理  -->
  <servlet>
        <servlet-name>app</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <!-- spring mvc配置文件实例化容器 （servlet WebApplicationContext 可以访问root） -->
            <param-value>classpath:springmvc-configure.xml</param-value>
        </init-param>
        <!-- 在服务器启动的时候就初始化servlet -->
        <load-on-startup>1</load-on-startup>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>app</servlet-name>
        <!--处理应用下的所有请求  -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

pom.xml：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.xintoucloud</groupId>
  <artifactId>gsv</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>gsv</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.8.1</version>
      <scope>test</scope>
    </dependency>
    <!--mybatis-spring整合需要的文件  -->
	<dependency>
	    <groupId>org.mybatis</groupId>
	    <artifactId>mybatis-spring</artifactId>
	    <version>1.3.2</version>
	</dependency>
    <!-- mybatis整合需要的文件 -->
	<dependency>
	    <groupId>org.mybatis</groupId>
	    <artifactId>mybatis</artifactId>
	    <version>3.4.6</version>
	</dependency>
	<!-- mybatis日志文件 -->
	<dependency>
	    <groupId>log4j</groupId>
	    <artifactId>log4j</artifactId>
	    <version>1.2.17</version>
	</dependency>
	<!-- mysql-需要的文件 -->
	<dependency>
	    <groupId>mysql</groupId>
	    <artifactId>mysql-connector-java</artifactId>
	    <version>5.1.37</version>
	</dependency>
	<!-- spring相关的开始 -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-context</artifactId>
	    <version>5.1.2.RELEASE</version>
	</dependency>
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-tx</artifactId>
	    <version>5.1.3.RELEASE</version>
	</dependency>
	<dependency>
	    <groupId>org.aspectj</groupId>
	    <artifactId>aspectjweaver</artifactId>
	    <version>1.9.2</version>
	</dependency>
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-jdbc</artifactId>
	    <version>5.1.3.RELEASE</version>
	</dependency>
	<!-- spring相关的结束 -->
	<!-- https://mvnrepository.com/artifact/commons-dbcp/commons-dbcp -->
	<dependency>
	    <groupId>commons-dbcp</groupId>
	    <artifactId>commons-dbcp</artifactId>
	    <version>1.4</version>
	</dependency>
	<!-- spring与springmvc整合 -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-webmvc</artifactId>
	    <version>5.1.2.RELEASE</version>
	</dependency>
	<!-- 页面使用jsp所需要的开始 -->
	<dependency>
	    <groupId>javax.servlet</groupId>
	    <artifactId>jstl</artifactId>
	    <version>1.2</version>
	</dependency>
	<dependency>
	    <groupId>javax.servlet</groupId>
	    <artifactId>javax.servlet-api</artifactId>
	    <version>4.0.1</version>
	    <scope>provided</scope>
	</dependency>
	<!-- 页面使用jsp所需要的结束 -->
	<!-- 控制器层将返回值转换成json类型所需要的 -->
	<dependency>
	    <groupId>com.fasterxml.jackson.core</groupId>
	    <artifactId>jackson-databind</artifactId>
	    <version>2.9.7</version>
	</dependency>
	<!-- jsr验证需要的 -->
	<dependency>
	    <groupId>org.hibernate.validator</groupId>
	    <artifactId>hibernate-validator</artifactId>
	    <version>6.0.13.Final</version>
	</dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.0</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
      <plugin>
		  <groupId>org.eclipse.jetty</groupId>
		  <artifactId>jetty-maven-plugin</artifactId>
		  <version>9.3.11.v20160721</version>
		  <configuration>
		    <scanIntervalSeconds>10</scanIntervalSeconds>
		    <webApp>  
		      <contextPath>/</contextPath>
		    </webApp>
		  </configuration>
		</plugin>
     </plugins>
   </build>
</project>

还有项目连接的数据库：MYSQL数据库

数据库名：gsv

表：就一张表t_user

用户名：root

密码：123456

 

好了：我们可以测试一下：

鼠标右键点击pom.xml->runAs->mavenbuild会出现：

goals中输入jetty:run点击run项目就启动了 ：

我们去地址栏中输入http://localhost:8080/user/list

看到已经成功了

添加测试：

 

添加成功。

修改测试：

 

我们把user9改成user10，密码改成654321

已经修改成功了

删除测试：我们把user7删掉

直接点击就删掉了。

好的基本的增删改查都已经成功了。

这篇博客已经写了将近一天了，算是写完了吧，但是还是有很多没有写上去的东西，还有很多没有说明白的地方，以后再继续完善，继续学习。