githhub源码下载
1.pom文件中添加依赖包
1)spring + junit4 测试
<!-- junit test start-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>4.3.8.RELEASE</version>
<scope>test</scope>
</dependency>
<!-- junit test end-->
2)数据库相关
<!-- database start -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.3.8.RELEASE</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.0.18</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.6</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.1</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.39</version>
</dependency>
<!-- database end -->
2. 创建DruidDatasource数据源
1)创建db.properties文件(在resources路径下)
##druid数据库连接池配置##
# MySql数据库连接信息
datasource.druid.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=UTF-8&useSSL=false
# 根据url自动识别 这一项可配可不配,
# 如果不配置druid会根据url自动识别dbType,
# 然后选择相应的driverClassName(建议配置下)
datasource.druid.drvierClassName=com.mysql.jdbc.Driver
datasource.druid.userName=root
datasource.druid.password=root
# 初始化时建立物理连接的个数
# 初始化发生在显示调用init方法,或者第一次getConnection时
datasource.druid.initialSize=5
# 最小连接池数量
datasource.druid.minIdle=5
# 最大连接池数量
datasource.druid.maxActive=25
# 获取最大连接时最大等待时间,单位时毫秒
# 配置了maxWait之后,缺省启用公平锁,并发效率会有所下降
# 如果需要可以通过配置useUnfairLock属性为true使用非公平锁
datasource.druid.maxWait=5000
# 是否缓存preparedStatement,也就是PSCache
# PSCache对支持游标的数据库性能提升巨大,比如说oracle.
# 在mysql下建议关闭
datasource.druid.poolPreparedStatements=false
# 当poolPreparedStatements配置为true时,才可以使用
# 要启用PSCache,必须配置大于0,当大于0时,poolPreparedStatements自动触发修改为true。
# 在Druid中,不会存在Oracle下PSCache占用内存过多的问题
# 可以把这个数值配置大一些,比如说100
#datasource.druid.maxOpenPreparedStatements=100
# 用来检测连接是否有效的sql,要求是一个查询语句
# 如果validationQuery为null,testOnBorrow、testOnReturn、testWhileIdle都不会其作用。
datasource.druid.validationQuery = SELECT 'x'
# 申请连接时执行validationQuery检测连接是否有效,做了这个配置会降低性能
# 开发时使用,生产环境建议关闭
# 默认值为true
datasource.druid.testOnBorrow=true
# 归还连接时执行validationQuery检测连接是否有效,做了这个配置会降低性能
# 默认值为false
datasource.druid.testOnReturn=false
# 建议配置为true,不影响性能,并且保证安全性.申请连接的时候检测
# 如果空闲时间大于timeBetweenEvictionRunsMillis
# 执行validationQuery检测连接是否有效
# 默认值为false
datasource.druid.testWhileIdle=true
# 1)Destroy线程会检测连接的间隔时间
# 2)testWhileIdle的判断依据
datasource.druid.timeBetweenEvictionRunsMillis=5000
#一个连接在池中最小生存的时间,单位是毫秒
datasource.druid.minEvictableIdleTimeMillis=300000
2) 创建DruidDataSourceConfig类
package com.roger.config;
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;
import org.springframework.context.annotation.PropertySource;
@Configuration
@PropertySource("classpath:db.properties")
public class DruidDataSourceConfig {
@Value("${datasource.druid.drvierClassName}")
private String driveClassName;
@Value("${datasource.druid.url}")
private String url;
@Value("${datasource.druid.userName}")
private String userName;
@Value("${datasource.druid.password}")
private String password;
@Value("${datasource.druid.initialSize}")
private int initialSize;
@Value("${datasource.druid.minIdle}")
private int minIdle;
@Value("${datasource.druid.maxActive}")
private int maxActive;
@Value("${datasource.druid.maxWait}")
private long maxWait;
@Value("${datasource.druid.poolPreparedStatements}")
private boolean poolPreparedStatements;
@Value("${datasource.druid.validationQuery}")
private String validationQuery;
@Value("${datasource.druid.testOnBorrow}")
private boolean testOnBorrow;
@Value("${datasource.druid.testOnReturn}")
private boolean testOnReturn;
@Value("${datasource.druid.testWhileIdle}")
private boolean testWhileIdle;
@Value("${datasource.druid.timeBetweenEvictionRunsMillis}")
private long timeBetweenEvictionRunsMillis;
@Value("${datasource.druid.minEvictableIdleTimeMillis}")
private long minEvictableIdleTimeMillis;
@Value("${datasource.druid.filters}")
private String filters;
@Bean
public DruidDataSource dataSource(){
DruidDataSource druidDataSource = new DruidDataSource();
druidDataSource.setDriverClassName(driveClassName);
druidDataSource.setUrl(url);
druidDataSource.setUsername(userName);
druidDataSource.setPassword(password);
druidDataSource.setInitialSize(initialSize);
druidDataSource.setMinIdle(minIdle);
druidDataSource.setMaxActive(maxActive);
druidDataSource.setMaxWait(maxWait);
druidDataSource.setPoolPreparedStatements(poolPreparedStatements);
druidDataSource.setValidationQuery(validationQuery);
druidDataSource.setTestOnBorrow(testOnBorrow);
druidDataSource.setTestOnReturn(testOnReturn);
druidDataSource.setTestWhileIdle(testWhileIdle);
druidDataSource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
druidDataSource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
return druidDataSource;
}
}
3)创建junit测试类TestDruidDataSource
package com.roger;
import com.roger.config.DruidDataSourceConfig;
import com.roger.config.MyBatisConfig;
import com.roger.config.SpringBeanConfig;
import com.roger.config.SpringTXConfig;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {DruidDataSourceConfig.class, MyBatisConfig.class, SpringTXConfig.class, SpringBeanConfig.class})
public class SpringBaseTestSuit {
}
package com.roger.config;
import com.alibaba.druid.pool.DruidDataSource;
import com.roger.SpringBaseTestSuit;
import org.junit.Assert;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
public class TestDruidDataSource extends SpringBaseTestSuit {
@Autowired
private DruidDataSource dataSource;
@Test
public void testInjectDruidDataSource() throws Exception{
dataSource.getConnection();
Assert.assertEquals(dataSource.getInitialSize(),dataSource.getCreateCount());
}
}
3.创建SqlSessionFactory以及操作数据库的Mapper接口
1创建MyBatisConfig
package com.roger.config;
import com.roger.constant.SystemConstant;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.omg.SendingContext.RunTime;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import javax.sql.DataSource;
import java.io.IOException;
@Configuration
@Import(DruidDataSourceConfig.class)
public class MyBatisConfig {
@Bean(name = "sqlSessionFactory")
public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) throws IOException {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSource);
ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
sqlSessionFactoryBean.setMapperLocations(resourcePatternResolver.getResources(SystemConstant.MAPPER_XML_PATH));
sqlSessionFactoryBean.setTypeAliasesPackage(SystemConstant.TYPE_ALIASES_PACKAGE);
return sqlSessionFactoryBean;
}
@Bean
public MapperScannerConfigurer mapperScannerConfigurer(){
MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
mapperScannerConfigurer.setBasePackage(SystemConstant.MAPPER_SCAN_BASE_PACKAGE);
return mapperScannerConfigurer;
}
}
2.创建一个SystemConstant类
package com.roger.constant;
public class SystemConstant {
public static final String TYPE_ALIASES_PACKAGE = "com.roger.entity";
public static final String MAPPER_SCAN_BASE_PACKAGE = "com.roger.mapper";
public static final String MAPPER_XML_PATH = "classpath:mapper/*Mapper.xml";
public static final String COMPONENT_SCAN_PACKAGE = "com.roger";
}
3.创建实体类User和UserMapper接口
package com.roger.entity;
public class User {
private int id;
private String userName;
private int age;
private String phone;
private String desc;
}
package com.roger.mapper;
import com.roger.entity.User;
import java.util.List;
public interface UserMapper {
List<User> getUserList();
}
4)创建UserMappper.xml文件(在resources/mapper路径下)
<?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.roger.mapper.UserMapper">
<select id="getUserList" resultType="User">
SELECT id,username,age,phone,'desc' FROM user
</select>
</mapper>
5.创建junit测试类TestUserMapper ( 要在父类 SpringBaseTestSuit 添加MyBatisConfig.class)
package com.roger.mapper;
import com.roger.SpringBaseTestSuit;
import com.roger.entity.User;
import org.junit.Assert;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
public class TestUserMapper extends SpringBaseTestSuit {
@Autowired
private UserMapper userMapper;
@Test
public void testGetUserList(){
List<User> users = userMapper.getUserList();
Assert.assertTrue(users.size() >= 0);
}
}
4.添加事务
1) 创建JavaBean 配置Java类
package com.roger.config;
import com.roger.constant.SystemConstant;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan(SystemConstant.COMPONENT_SCAN_PACKAGE)
public class SpringBeanConfig {
}
2)创建事务管理器 DataSourceTransactionManager
package com.roger.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.sql.DataSource;
@Configuration
@Import(DruidDataSourceConfig.class)
@EnableTransactionManagement
public class SpringTXConfig {
@Bean
public DataSourceTransactionManager transactionManager(DataSource dataSource){
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
transactionManager.setDataSource(dataSource);
return transactionManager;
}
}
3)创建Service接口及其实现类
package com.roger.service;
import com.roger.entity.User;
import java.util.List;
public interface UserService {
List<User> getUserList();
int insertUser(User user);
}
package com.roger.service.impl;
import com.roger.entity.User;
import com.roger.mapper.UserMapper;
import com.roger.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserMapper userMapper;
@Override
public List<User> getUserList() {
return userMapper.getUserList();
}
@Transactional
@Override
public int insertUser(User user) {
return userMapper.insertUser(user);
}
}
4)创建测试类
package com.roger.service;
import com.roger.SpringBaseTestSuit;
import com.roger.entity.User;
import org.junit.Assert;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
public class TestUserServiceImpl extends SpringBaseTestSuit {
@Autowired
private UserService userService;
@Test
public void testInsertUser(){
User user = new User();
user.setAge(19);
user.setPhone("16422455");
user.setUserName("Mary");
user.setDesc("Pretty");
int count = userService.insertUser(user);
Assert.assertTrue(count >= 0);
}
}