Java开发环境之Spring+SpringMVC+Mybatis整合demo

开始学习java开源框架，今天带来的是Spring+SpringMVC+Mybatis框架的整合，并附带一个简单的用户增删该查demo，如有不严谨的地方，恳请各位大神指正，谢谢！

我所用到的框架版本是Spring3.2.13，Mybatis3.2.8，数据库用的是MySQL所用的开发IDE是Eclipse（Myeclipse和eclipse一样就不重复演示了）好了不说废话了，进入正题！！！

1，在eclipse中创建动态web项目spring_mvc_mybatis

2，导入jar包

2.1导入spring包，所有19个

2.2，导入mybatis包和整合包2个

2.3，导入数据库驱动

2.4，导入数据源和连接池（dbcp或者c3p0），我这里用的是dbcp2个

2.5，AOP依赖包3个，aop代理1个

2.6，日志包commons-logging.jar   log4j.jar两个

2.7，标签库jstl.jar   standard.jar两个

2.8，文件上传commons-io commons-fileupload commons-lang三个

2.9，json支持jackson包

2.10，导入Junit单元测试包

3，在web.xml中创建spring Servlet容器，和中文编码过滤器

 
  <servlet>
  <servlet-name>may26test</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <init-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath:beans.xml</param-value>
  </init-param>
  </servlet>
  <servlet-mapping>
  <servlet-name>may26test</servlet-name>
  <url-pattern>*.do</url-pattern>
  </servlet-mapping>

  <!-- 解决中文乱码问题 -->
  <filter>
  <filter-name>characterEncoding</filter-name>
  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  <init-param>
  <param-name>encoding</param-name>
  <param-value>utf-8</param-value>
  </init-param>
  </filter>
  <filter-mapping>
  <filter-name>characterEncoding</filter-name>
  <url-pattern>*.do</url-pattern>
  </filter-mapping>

4，创建beans.xml(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"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:mybatis-spring="http://mybatis.org/schema/mybatis-spring"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.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/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd
http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring-1.2.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">

<!-- 开启IOC注解扫描 -->
 <context:component-scan base-package="com.may26.testuser"/>

<!-- 开启MVC注解扫描 -->
 <mvc:annotation-driven></mvc:annotation-driven>

<!-- 处理请求转发 -->
 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"/>
<property name="suffix" value=".jsp"/>
</bean>

<!-- 数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="${jdbc.driverClassName}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!-- 导入外部properties文件配置 -->
<context:property-placeholder location="classpath:jdbc.properties"/>

<!-- MyBatis SessionFactory -->
<bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="mapperLocations" value="classpath:com/may26/testuser/dao/*/*.xml"></property>
</bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.may26.testuser"></property>
<!-- 指定注解,只扫描带有该注解的mapper -->
<property name="annotationClass" value="com.may26.testuser.base.MybatisRepository"></property>
</bean>

<!-- 配置Spring的事务处理(这里采用注解的方式,也可以使用xml的方式) -->
<!-- 创建事务管理器  -->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
  </bean>
<!--  配置哪些方法要加入事务控制 -->
<tx:annotation-driven transaction-manager="txManager"></tx:annotation-driven>


</beans>

5，引入jdbc.properties 和log4j.properties配置文件，至此，准备工作就做完了，接下来了做一个简单的用户增删该查，测试一下我们的环境是否正确

6，创建Mybatis的Annotation--->MybatisRepositoryspring容器在扫描的时候只扫描带有该注解的mapper

package com.may26.testuser.base;

import org.springframework.stereotype.Component;

@Component
public @interface MybatisRepository {

}

7，创建实体类User

package com.may26.testuser.entity;

public class User {
private Integer id;
private String name;
private String loginName;
private String password;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLoginName() {
return loginName;
}
public void setLoginName(String loginName) {
this.loginName = loginName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}

}

8，创建dao（mapper）接口，实现实体的CRUD

8.1BaseDao

package com.may26.testuser.base;

import java.util.List;

public interface BaseDao<T> {
/**查询所有*/
List<T> listAll();
/**根据id查询实体*/
T findById(Integer id);
/**根据名称查找实体*/
T findByName(String name);
/**增加实体*/
void save(T emtity);
/**删除实体*/
void delete(Integer id);
/**更新实体*/
void update(T entity);
}

8.2，UserMapper

package com.may26.testuser.dao;

import com.may26.testuser.base.BaseDao;
import com.may26.testuser.base.MybatisRepository;
import com.may26.testuser.entity.User;

@MybatisRepository
public interface UserMapper extends BaseDao<User> {
/**根据登陆名查找用户*/
User findByLoginName(String longinName);

}

9，创建UserMapper.xml文件

<?xml version="1.0" encoding="UTF-8" ?>  
<!DOCTYPE mapper PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"      
 "http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd">
<!-- 根元素是mapper 属性namespace的值是mapper接口全名 -->
<mapper namespace="com.may26.testuser.dao.UserMapper">

<insert id="save" parameterType="com.may26.testuser.entity.User">
insert into user (id,name,loginName,password) values (
#{id},
#{name},
#{loginName},
#{password}
)
</insert>

<delete id="delete" parameterType="int">
delete from user where id = #{id}
</delete>

<update id="update" parameterType="com.may26.testuser.entity.User">
update user set
name=#{name},
loginName=#{loginName},
password=#{password}
where id=#{id}
</update>

<select id="findById" parameterType="int" resultType="com.may26.testuser.entity.User">
select * from user where id =#{id}
</select>

<select id="findByName" parameterType="string" resultType="com.may26.testuser.entity.User">
select * from user where name =#{name}
</select>

<select id="findByLoginName" parameterType="string" resultType="com.may26.testuser.entity.User">
select * from user where loginName =#{loginName}
</select>

<select id="listAll" resultType="com.may26.testuser.entity.User">
select * from user
</select>

</mapper>

10，测试Mapper

package com.may26.testuser.test;

import java.util.List;

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

import com.may26.testuser.dao.UserMapper;
import com.may26.testuser.entity.User;

public class TestUserMapper {
private ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
private UserMapper userMapper = ctx.getBean(UserMapper.class);

@Test
public void testSave(){
for(int i = 0;i<=10;i++){
User u = new User();
u.setName("李四"+i);
u.setLoginName("ls"+i);
u.setPassword("123");
userMapper.save(u);
}
}

@Test
public void testDelete(){
userMapper.delete(1);
}

@Test
public void testFindById(){
User u = userMapper.findById(2);
System.out.println(u.getName()+"---"+u.getLoginName()+"---"+u.getPassword());

}

@Test
public void testFindByName(){
User u = userMapper.findByName("张三");
System.out.println(u.getName()+"---"+u.getLoginName()+"---"+u.getPassword());

}

@Test
public void testFindByLoginName(){
User u = userMapper.findByLoginName("zs");
System.out.println(u.getName()+"---"+u.getLoginName()+"---"+u.getPassword());

}

@Test
public void testListAll(){
List<User> list = userMapper.listAll();
for(User u : list){
System.out.println(u.getName());
}
}
}

11，service层

package com.may26.testuser.service;

import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.may26.testuser.dao.UserMapper;
import com.may26.testuser.entity.User;

@Service
@Transactional
public class UserService {

@Resource
private UserMapper userMapper;

public List<User> listAll() {
List<User> list = userMapper.listAll();
return list;
}

public User findById(int id) {
User u = userMapper.findById(id);
return u;
}

public void saveUser(String name, String loginName, String password) {
User u = new User();
u.setLoginName(loginName);
u.setName(name);
u.setPassword(password);
userMapper.save(u);
}

public void deleteUser(int id) {
userMapper.delete(id);
}

public void updateUser(int id, String name, String loginName,
String password) {
//需要判断参数是否为空
User u = userMapper.findById(id);
u.setLoginName(loginName);
u.setName(name);
u.setPassword(password);
userMapper.update(u);
}

}

12，controller层

package com.may26.testuser.web;

import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import com.may26.testuser.entity.User;
import com.may26.testuser.service.UserService;

@Controller
@RequestMapping("user")
public class UserController{
@Resource
private UserService userService;

@RequestMapping(value="list.do")
//@ResponseBody
public String listAll(Model model){
List<User> userList = userService.listAll();
model.addAttribute("userList", userList);
//return userList;
return "/user/list";
}

/**用户详细信息*/
@RequestMapping("userInfo.do")
public String findById(int id,Model model){
User user = userService.findById(id);
model.addAttribute("user", user);
return "/user/userInfo";
}

/**增加用户*/
@RequestMapping("add.do")
public String saveUser(String name,String loginName,String password,Model model){
userService.saveUser(name,loginName,password);
List<User> userList = userService.listAll();
model.addAttribute("userList", userList);
return "/user/list";
}
@RequestMapping("addUI.do")
public String saveUserUI(){
return "/user/add";
}

/**删除用户*/
@RequestMapping("delete.do")
public String deleteUser(int id,Model model){
userService.deleteUser(id);
List<User> userList = userService.listAll();
model.addAttribute("userList", userList);
return "user/list";
}

/**修改用户*/
@RequestMapping("update.do")
public String updateUser(int id,String name,String loginName,String password ,Model model){
userService.updateUser(id,name,loginName,password);
List<User> userList = userService.listAll();
model.addAttribute("userList", userList);
return "user/list";
}
@RequestMapping("updateUI.do")
public String updateUserUI(int id,Model model){
User user = userService.findById(id);
model.addAttribute("user", user);
return "user/update";
}

}

13，JSP页面

好了，完整的Spring+SpringMVC+Mybatis整合到此结束了，欢迎观看