springboot-druid数据源

    DRUID是阿里巴巴开源平台上一个数据库连接池实现，它结合了C3P0、DBCP、PROXOOL等DB池的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池(据说是目前最好的连接池,不知道速度有没有BoneCP快)。

创建项目

创建项目如下：

在pom.xml中引入依赖jar包

<?xml version="1.0" encoding="UTF-8"?>
<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.example.springboot</groupId>
   <artifactId>springboot-druid</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>springboot-druid</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.12.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.7</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      <!-- spring,mybatis整合包 -->
      <dependency>
         <groupId>org.mybatis.spring.boot</groupId>
         <artifactId>mybatis-spring-boot-starter</artifactId>
         <version>1.3.2</version>
      </dependency>
      <!-- mysql 驱动包 -->
      <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <scope>runtime</scope>
      </dependency>
      <!-- springboot,druid 整合包 -->
      <!--<dependency>-->
      <!--<groupId>com.alibaba</groupId>-->
      <!--<artifactId>druid-spring-boot-starter</artifactId>-->
      <!--<version>1.1.8</version>-->
      <!--</dependency>-->
      <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>druid</artifactId>
         <version>1.1.8</version>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

创建表结构

-- ----------------------------
-- Table structure for `m_user`
-- ----------------------------
DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user` (
  `id` varchar(50) NOT NULL DEFAULT '0',
  `username` varchar(50) DEFAULT NULL,
  `password` varchar(50) DEFAULT NULL,
  `email` varchar(50) DEFAULT NULL,
  `useable` int(11) DEFAULT NULL,
  `addtime` varchar(50) DEFAULT NULL,
  `logintime` varchar(50) DEFAULT NULL,
  `loginip` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of m_user
-- ----------------------------
INSERT INTO `t_user` VALUES ('1', '1111', '1111', '1111', '11', '1111', '111', '111');

创建User实体类

扫描二维码关注公众号，回复： 146182 查看本文章

package com.example.springboot.druid.entity;

public class User {
   private String id;

   private String username;

   private String password;

   private String email;

   /**
    * 是否可用(0禁用,1可用)
    */
   private Integer useable;

   /**
    * 创建时间
    */
   private String addtime;

   /**
    * 登陆时间
    */
   private String logintime;

   /**
    * 登陆IP
    */
   private String loginip;

创建dao接口

package com.example.springboot.druid.dao;

import com.example.springboot.druid.entity.User;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;

/**
 * 基于接口编程，通过mybatis与spring整合注入，在xml中编写sql语句
 */
@Mapper
public interface UserMapper {

   List<User> queryList();

   void save(User user);

   void batchDelete(String[] ids);

   void update(User user);

   User getUserById(String id);

}

创建service服务层类

package com.example.springboot.druid.service;

import com.example.springboot.druid.dao.UserMapper;
import com.example.springboot.druid.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;

/**
* @desc 通过mybatis xml配置文件读取数据
* @Author wangsh
* @date 2018/5/6 12:11
* @return 
*/
@Service
public class UserService {

   @Autowired
   private UserMapper userMapper;

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

   public void batchDelete(String[] ids) {
      userMapper.batchDelete(ids);
   }

   // REQUIRED:表示必须又事物管理，如果没有事物，就创建一个事物
   @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, timeout = 36000, rollbackFor = Exception.class)
   public void update(User user) {
      userMapper.update(user);
   }

   // REQUIRED:表示必须又事物管理，如果没有事物，就创建一个事物
   @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, timeout = 36000, rollbackFor = Exception.class)
   public void save(User user) {
      userMapper.save(user);
   }

   public User getUserById(String id) {
      return userMapper.getUserById(id);
   }
}

创建controller类

package com.example.springboot.druid.web;

import com.example.springboot.druid.entity.User;
import com.example.springboot.druid.service.UserService;
import com.example.springboot.druid.util.UUIDUtil;
import com.github.pagehelper.PageHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;

/**
* @desc mybatis 操作数据库查询示例
* @Author wangsh
* @date 2018/5/6 12:11
* @return 
*/
@RestController
@RequestMapping("/user")
public class UserController {
   /**
    * 通过mybatis xml配置文件读取数据
    */
   @Autowired
   private UserService userService;

   @RequestMapping("/getUserById")
   @ResponseBody
   public User getUserById(String id) {
      User User = userService.getUserById(id);
      return User;
   }

   @RequestMapping("/queryList")
   @ResponseBody
   public List<User> queryList() {
      // 设置分页
      PageHelper.startPage(1, 2);
      List<User> queryList = userService.queryList();
      return queryList;
   }

   @RequestMapping("/save")
   @ResponseBody
   public User save() {
      User user = new User();
      user.setId(UUIDUtil.getUUID());
      user.setUsername("lisi");
      user.setPassword("lisi");
      userService.save(user);
      return user;
   }
}

创建工具类

package com.example.springboot.druid.util;

import java.util.UUID;

public class UUIDUtil {
   public static void main(String[] args) {
      System.out.println(getUUID());
   }

   public static String getUUID() {
      String str = UUID.randomUUID().toString().replace("-", "");
      return str;
   }
}

创建durild数据源配置

package com.example.springboot.druid.conf;

import com.alibaba.druid.filter.Filter;
import com.alibaba.druid.filter.stat.StatFilter;
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.Arrays;

/**
 * @desc 创建druid数据源
 * @Author wangsh
 * @date 2018/5/6 12:12
 * @return
 */
@Configuration
public class DruidConfiguration {

   /**
    * @return
    * @desc 通过配置文件获取durid数据库配置，初始化数据源
    * @Author wangsh
    * @date 2018/5/6 12:02
    */
   @ConfigurationProperties(prefix = "spring.datasource.druid")
   @Bean(initMethod = "init", destroyMethod = "close")
   public DruidDataSource dataSource() {
      DruidDataSource ds = new DruidDataSource();
      ds.setProxyFilters(Arrays.asList(statFilter()));
      return ds;
   }

   @Bean
   public Filter statFilter() {
      StatFilter filter = new StatFilter();
      filter.setSlowSqlMillis(5000);
      filter.setLogSlowSql(true);
      filter.setMergeSql(true);
      return filter;
   }
}

创建mybatis数据源配置

在src\main\resources\mybatis\目录下创建mybatis-config.xml配置文件

package com.example.springboot.druid.conf;

import com.github.pagehelper.PageHelper;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import javax.sql.DataSource;
import java.util.Properties;


/**
 * @desc Mybatis加载配置文件及初始化dao层mapper接口类，可以通过在配置文件中增加mybatis配置，也可以使用以下代码初始化，
 * 不建议使用该中方式，在项目维护中不方便；项目中常用在配置文件中添加mybatis配置，让spring自动管理。
 * @Author wangsh
 * @date 2018/5/6 12:12
 * @return
 */
//通过Configuration注解加载到spring容器，如需要手动注入，则打开@Configuration注解
//@Configuration
public class MyBatisConfiguration {

   @Bean
   @ConditionalOnMissingBean // 当容器里没有指定的 Bean 的情况下创建该对象
   public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) {
      SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
      // 设置数据源
      sqlSessionFactoryBean.setDataSource(dataSource);
      // 设置mybatis的主配置文件
      sqlSessionFactoryBean.setConfigLocation(new ClassPathResource("mybatis/mybatis-config.xml"));
      // 设置mapper映射文件
      PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
//    Resource[] mapperXml;
//    try {
//       mapperXml = resolver.getResources("classpath:mybatis/mapper/*.xml");
//       sqlSessionFactoryBean.setMapperLocations(mapperXml);
//    } catch (IOException e) {
//       e.printStackTrace();
//    }
      // 设置别名包
//    sqlSessionFactoryBean.setTypeAliasesPackage("com.example.springboot.druid.entity");

      return sqlSessionFactoryBean;
   }

   /**
    * @desc 可以通过代码注入dao层mapper接口，也可以通过配置文件加载，自动注入
    * @Author wangsh
    * @date 2018/5/6 11:59
    * @return
    */
   // 当 SqlSessionFactoryBean 实例存在时创建对象
// @Bean
// @ConditionalOnBean(SqlSessionFactoryBean.class)
// public MapperScannerConfigurer mapperScannerConfigurer() {
//    MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
//    mapperScannerConfigurer.setBasePackage("com.example.springboot.druid.dao");
//    return mapperScannerConfigurer;
// }

   /**
    * @return
    * @desc 分页处理类
    * @Author wangsh
    * @date 2018/5/6 11:58
    */
   @Bean
   public PageHelper pageHelper() {
      PageHelper page = new PageHelper();
      Properties p = new Properties();
      p.setProperty("offsetAsPageNum", "true");
      p.setProperty("rowBoundsWithCount", "true");
      p.setProperty("reasonable", "true");
      page.setProperties(p);
      return page;
   }
}

创建mybatis-config.xml配置文件

在src\main\resources\mybatis\mapper\目录下创建UserMapper.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>
    <settings>
        <!-- 获取数据库自增主键值 -->
        <setting name="useGeneratedKeys" value="true"/>
        <!-- 使用列别名替换列名，默认为 true -->
        <setting name="useColumnLabel" value="true"/>
        <!-- 开启驼峰命名转换：Table(create_time) => Entity(createTime) -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>

        <!-- 使全局的映射器启用或禁用缓存。 -->
        <setting name="cacheEnabled" value="true"/>
        <!-- 全局启用或禁用延迟加载。当禁用时，所有关联对象都会即时加载。 -->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!-- 当启用时，有延迟加载属性的对象在被调用时将会完全加载任意属性。否则，每种属性将会按需要加载。 -->
        <setting name="aggressiveLazyLoading" value="true"/>
        <!-- 是否允许单条sql 返回多个数据集  (取决于驱动的兼容性) default:true -->
        <setting name="multipleResultSetsEnabled" value="true"/>

        <!-- 指定 MyBatis 如何自动映射 数据基表的列 NONE：不隐射　PARTIAL:部分  FULL:全部  -->
        <setting name="autoMappingBehavior" value="PARTIAL"/>
        <!-- 这是默认的执行类型  （SIMPLE: 简单； REUSE: 执行器可能重复使用prepared statements语句；BATCH: 执行器可以重复执行语句和批量更新）  -->
        <setting name="defaultExecutorType" value="SIMPLE"/>

        <setting name="defaultStatementTimeout" value="25"/>

        <setting name="defaultFetchSize" value="100"/>

        <setting name="safeRowBoundsEnabled" value="false"/>
        <!-- 使用驼峰命名法转换字段。 -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!-- 设置本地缓存范围 session:就会有数据的共享  statement:语句范围 (这样就不会有数据的共享 ) defalut:session -->
        <setting name="localCacheScope" value="SESSION"/>
        <!-- 默认为OTHER,为了解决oracle插入null报错的问题要设置为NULL -->
        <setting name="jdbcTypeForNull" value="NULL"/>
        <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
    </settings>

</configuration>

创建服务启动类

package com.example.springboot.druid;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.transaction.annotation.EnableTransactionManagement;

//初始化扫描包
@ComponentScan("com.example.springboot.*")
//增加事物管理
@EnableTransactionManagement
@SpringBootApplication
public class SpringbootDruidApplication {

   public static void main(String[] args) {
      SpringApplication.run(SpringbootDruidApplication.class, args);
   }
}

启动服务测试

服务启动如下：

保存测试，浏览器访问：http://localhost:8080/user/save

数据库表数据：

查询测试，浏览器访问：