爬山的蜗牛旅程：七、springboot整合阿里Druid+SpringData Jpa+Spring JDBC+事务

学习springboot的旅程，就像蜗牛爬山，一点点的往上爬，一点点的欣赏旅途的风景

继续上一章的问题，小猿在遁入佛门前想起了数据库链接池没搞？数据持久层也没搞？

他想了想，先搞个阿里连接池先，然后选择 springdata 的 jpa模块 作为持久层实现。

---

Druid阿里连接池管理框架

• 第一步：pom.xml 引入Druid和对应数据库驱动（我这里引入了oracle驱动）

		<!-- 引入druid依赖 -->
        <!-- 此处的引用有两种 -->
        <!-- 一种是直接引用druid包,另一种是引用starter方式 -->
        <!-- 在此处我引用的是start包,为什么呢，因为方便呀... -->
        <!-- 注:如果没有该包,application.properties/application.yml 中将不会出现关于druid的提示 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

        <!-- oracle驱动 -->
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>11.2.0.3</version>
            <scope>runtime</scope>
        </dependency>

• 第二步：在application.properties(application.ymx)配置数据源和连接池信息

#####jdbc配置
spring.datasource.url=jdbc:oracle:thin:@localhost:1521:ORCL
spring.datasource.username=hxz
spring.datasource.password=hxz
#这里是数据库驱动，以实际数据库为准
spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

#连接池的设置
#初始化时建立物理连接的个数
spring.datasource.druid.initial-size=5
#最小连接池数量
spring.datasource.druid.min-idle=5
#最大连接池数量 maxIdle已经不再使用
spring.datasource.druid.max-active=20
#获取连接时最大等待时间，单位毫秒
spring.datasource.druid.max-wait=60000
#申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
spring.datasource.druid.test-while-idle=true
#既作为检测的间隔时间又作为testWhileIdel执行的依据
spring.datasource.druid.time-between-eviction-runs-millis=60000
#销毁线程时检测当前连接的最后活动时间和当前时间差大于该值时，关闭当前连接
spring.datasource.druid.min-evictable-idle-time-millis=30000
#用来检测连接是否有效的sql 必须是一个查询语句
#mysql中为 select 'x'
#oracle中为 select 1 from dual
spring.datasource.druid.validation-query=select 1 from dual
#申请连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
spring.datasource.druid.test-on-borrow=false
#归还连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
spring.datasource.druid.test-on-return=false
#当数据库抛出不可恢复的异常时,抛弃该连接
#spring.datasource.druid.exception-sorter=true
#是否缓存preparedStatement,mysql5.5+建议开启 下面这个属性只有mysql有#spring.datasource.druid.pool-prepared-statements=true
#当值大于0时poolPreparedStatements会自动修改为true
spring.datasource.druid.max-pool-prepared-statement-per-connection-size=20
#配置扩展插件
spring.datasource.druid.filters=stat,wall
#通过connectProperties属性来打开mergeSql功能；慢SQL记录
spring.datasource.druid.connection-properties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
#合并多个DruidDataSource的监控数据
spring.datasource.druid.use-global-data-source-stat=true
#设置访问druid监控页的账号和密码,默认没有
spring.datasource.druid.stat-view-servlet.login-username=admin
spring.datasource.druid.stat-view-servlet.login-password=admin

• 然后，就没然后了，已经配置好了，可以直接用了！

SpringData Jpa持久层

• 第一步：pom.xml引入SpringData Jpa模块

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

• 第二步：在application.properties(application.ymx)配置Jpa

#jpa设置
#指定数据库类型
spring.jpa.database=oracle
#控制台输出执行sql
spring.jpa.show-sql=true
#根据实体字段自动同步数据库表结构（直白说，根据实体创建数据库表）
spring.jpa.hibernate.ddl-auto=update

• 到此Jpa的环境也搞好了。

简单的Jpa例子

• 第一步：创建视图

import com.fasterxml.jackson.annotation.JsonFormat;
import org.hibernate.annotations.GenericGenerator;
import org.springframework.format.annotation.DateTimeFormat;
import javax.persistence.*;
import java.util.Date;
@Entity
@Table(name = "AAAA")
public class User {
    @Id
    @GeneratedValue(generator = "faceset_generator")
    @GenericGenerator(name = "faceset_generator", strategy = "uuid")
    private String id;


    @Column(name="NAME",nullable = false ,length=1000)
    private String name;

    @Column(nullable = false)
    private String sex;

    @Column(nullable = false)
    private String age;

    @Column(nullable = false)
    private String address;

    @Column(nullable = false)
    private String remarks;

    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
    @Column(name="CREATETIME",nullable = false)
    private Date createtime;

    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public String getRemarks() {
        return remarks;
    }
    public void setRemarks(String remarks) {
        this.remarks = remarks;
    }
    public Date getCreatetime() { return createtime; }
    public void setCreatetime(Date createtime) { this.createtime = createtime; }
}

• 第二步：编写Jpa的接口（是接口，是接口，是接口，不是实现！！！！）

import com.example.hxzboot.Dome.Sys.User.Entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface UserRepository extends JpaRepository<User,String> {
   //就是一个接口，什么实现都没有，你没看错！！就是这样！！！
}

• 第三步：在业务层或者控制层注入，并使用增删查改

import com.example.hxzboot.Dome.Sys.User.Entity.User;
import com.example.hxzboot.Dome.Sys.Core.Service.impl.CoreServiceImpl;
import com.example.hxzboot.Dome.Sys.User.Service.UserRepository;
import com.example.hxzboot.Dome.Sys.User.Service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.ExampleMatcher;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Map;
@Service("userService")
@Transactional
public class UserServiceImpl {
    //----注意-----看下面的说明
    /**
    *  1-UserRepository userRepository 就是上面第二步的接口（没有实现）
    *  2-不用实现UserRepository接口，能直接使用增删查改
    *  3-不用实现UserRepository接口，因为注入的UserRepository是由Jpa来实现
    **/
    @Autowired
    private UserRepository userRepository;

    @Override
    public List<User> findAll() {
        return userRepository.findAll();
    }
    @Override
    public User save(User user) {
        return userRepository.save(user);
    }
    @Override
    public User findById(String id) {
        return userRepository.findById(id).get();
    }
    @Override
    public void deleteById(String id) {
        userRepository.deleteById(id);
    }
}

springboot+JdbcTemplate+Jpa整合（实现既可以JDBC、又可以ORM）

• 说明一下：springboot本身就已经实现对JdbcTemplate的支持
  • 只要配置数据源，就可以注入JdbcTemplate使用
  • 数据源配置请看：阿里连接池的第二步配置
• 第一步：编写JDBC通用接口及实现（通用的），实现一次就够了！！！

import java.util.List;
import java.util.Map;
public interface CoreService {
    public List<Map<String,Object>> queryForList(String sql, Object ...obj);
    public void execute(String sql);
    public int update(String sql,Object ...obj);
    public int[] batchUpdate(String sql);
    public int[] batchUpdate(String sql,List<Object[]> lsobj);
}

import com.example.hxzboot.Dome.Sys.Core.Service.CoreService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.Map;
@Service("coreService")
@Transactional
public class CoreServiceImpl implements CoreService {
    @Autowired
    protected JdbcTemplate jdbcTemplate;
    @Override
    public List<Map<String, Object>> queryForList(String sql, Object... obj) {
        return jdbcTemplate.queryForList(sql,obj);
    }
    @Override
    public void execute(String sql) {
        jdbcTemplate.execute(sql);
    }
    @Override
    public int update(String sql, Object... obj) {
        return jdbcTemplate.update(sql,obj);
    }
    @Override
    public int[] batchUpdate(String sql) {
        return jdbcTemplate.batchUpdate(sql);
    }
    @Override
    public int[] batchUpdate(String sql, List<Object[]> lsobj) {
        return jdbcTemplate.batchUpdate(sql, lsobj);
    }
}

• 第二步：编写两个业务接口（jpa和jdbc），比如user

import com.example.hxzboot.Dome.Sys.User.Entity.User;
import com.example.hxzboot.Dome.Sys.Core.Service.CoreService;
import org.springframework.data.domain.ExampleMatcher;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import java.util.List;
/**
* JDBC业务接口，必须继承JDBC通用接口CoreService 
* 注意：所有持久层方法，都在这定义，不用在Jpa业务接口上定义
*/
public interface UserService extends CoreService {
    public Page<User> findAllByProperty(User user, ExampleMatcher matcher,Pageable pageable);
    public List<User> findAllByProperty(User user, ExampleMatcher matcher);
    public Page<User> findAll(Pageable pageable);
    public List<User> findAll();
    public User save(User user) ;
    public User findById(String id);
    public void deleteById(String id);
}

import com.example.hxzboot.Dome.Sys.User.Entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
/**
* Jpa的接口，啥都不用实现！！！
* 注意：持久层方法不在此定义！！在JDBC业务接口上定义
*/
@Repository
public interface UserRepository extends JpaRepository<User,String> {
}

• 第三步：业务层实现（此处是业务实现，必须加事务）

import com.example.hxzboot.Dome.Sys.User.Entity.User;
import com.example.hxzboot.Dome.Sys.Core.Service.impl.CoreServiceImpl;
import com.example.hxzboot.Dome.Sys.User.Service.UserRepository;
import com.example.hxzboot.Dome.Sys.User.Service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.ExampleMatcher;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.Map;
@Service("userService")
@Transactional//增加事务
public class UserServiceImpl extends CoreServiceImpl implements UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Override
    public List<User> findAllByProperty(User user, ExampleMatcher matcher) {
        Example<User> example;
        if(null==matcher){
            example = Example.of(user);
        }else{
            example = Example.of(user,matcher);
        }
        return userRepository.findAll(example);
    }

    @Override
    public Page<User> findAllByProperty(User user, ExampleMatcher matcher,Pageable pageable) {
        Example<User> example;
        if(null==matcher){
            example = Example.of(user);
        }else{
            example = Example.of(user,matcher);
        }
        return userRepository.findAll(example,pageable);
    }
    
    @Override
    public List<User> findAll() {
        return userRepository.findAll();
    }
    
    @Override
    public User save(User user) {
        return userRepository.save(user);
    }

    @Override
    public User findById(String id) {
        return userRepository.findById(id).get();
    }

    @Override
    public void deleteById(String id) {
        userRepository.deleteById(id);
    }

    @Override
    public Page<User> findAll(Pageable pageable) {
        return userRepository.findAll(pageable);
    }
}

• 第四步：在controller使用

import com.alibaba.fastjson.JSONObject;
import com.example.hxzboot.Dome.Sys.User.Entity.User;
import com.example.hxzboot.Dome.Sys.User.Service.UserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.ExampleMatcher;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Api(tags="用户管理")
@RestController
@RequestMapping("/restuser")
public class RestUserController {
    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private UserService userService;

    @ApiOperation(value = "获取用户数据列表", notes = "获取所有用户数据列表")
    @RequestMapping(value = "/alluser" , method = {RequestMethod.GET,RequestMethod.POST})
    public List<User> usersList(){
        List<Map<String,Object>> ls=this.userService.queryForList("select * from aaaa");
        return userService.findAll();
    }

    /**
     * 获取列表数据
     * @return
     */
    @RequestMapping(value = "/query",method = {RequestMethod.POST,RequestMethod.GET})
    public String query(HttpServletRequest request,User user){
        Map<String,Object>   map=new HashMap<String,Object>();

        //获取当前页数
        String  pageNumber=  request.getParameter("pageNumber");
        int page=1;
        if(!StringUtils.isEmpty(pageNumber)){
            page=Integer.valueOf(pageNumber);
        }

        //设置查询条件
        User u=new User();
        if(user.getName()!=null&&user.getName()!=""){
            u.setName(user.getName());
        }
        if(user.getSex()!=null&&user.getSex()!=""){
            u.setSex(user.getSex());
        }
        if(user.getAge()!=null&&user.getAge()!=""){
            u.setAge(user.getAge());
        }
        if(user.getAddress()!=null&&user.getAddress()!=""){
            u.setAddress(user.getAddress());
        }
        if(user.getRemarks()!=null&&user.getRemarks()!=""){
            u.setRemarks(user.getRemarks());
        }

        //设置查询条件
        ExampleMatcher matcher = ExampleMatcher.matching()
                .withMatcher("name", ExampleMatcher.GenericPropertyMatchers.contains())//全部模糊查询，即%{name}%
                .withMatcher("sex" ,ExampleMatcher.GenericPropertyMatchers.contains())//全部模糊查询，即%{name}%
                .withMatcher("age" ,ExampleMatcher.GenericPropertyMatchers.contains())//全部模糊查询，即%{name}%
                .withMatcher("address" ,ExampleMatcher.GenericPropertyMatchers.contains())//全部模糊查询，即%{name}%
                .withMatcher("remarks" ,ExampleMatcher.GenericPropertyMatchers.contains());//全部模糊查询，即%{name}%

        //查询总条数
        List<User> users = userService.findAllByProperty(u,matcher);
        int sum=users.size()/10;
        if(users.size()%10>0){
            sum=++sum;
        }
        map.put("sum",sum);

        //在总数据里提取分页数据
        List<User> datas=new ArrayList<User>();
        for(int i=(page-1)*10;i<users.size()&&i<((page-1)*10+10);i++){
            datas.add(users.get(i));
        }
        
        map.put("list",datas);
        return JSONObject.toJSONString(map);
    }

    @ApiOperation(value = "更新用户", notes = "更新用户数据")
    @RequestMapping(value = "/updateuser" ,  method = RequestMethod.POST)
    public Map<String,Object> updateUser(User user)throws Exception{
        Map<String,Object> map=new HashMap<String,Object>();
        if(userService.save(user) != null){
            map.put("msg","更新成功");
            map.put("state","200");
            map.put("user",user);
        }else{
            map.put("msg","更新失败");
            map.put("state","500");
        }
        return map;
    }

    @ApiOperation(value = "获取用户", notes = "根据用户id获取用户")
    @RequestMapping(value="/getuserbyid",method = RequestMethod.POST)
    public User selectUserById(String id){
        return userService.findById(id);
    }

    @ApiOperation(value = "删除用户", notes = "根据用户id删除用户")
    @RequestMapping(value="/deleteuser",method = RequestMethod.POST)
    public Map<String,Object> deleteUser(String id){
        userService.deleteById(id);
        Map<String,Object> map=new HashMap<String,Object>();
        map.put("msg","删除成功");
        map.put("state","200");
        return map;
    }

    @ApiOperation(value = "保存用户", notes = "保存用户数据")
    @RequestMapping(value="/saveuser",method = {RequestMethod.POST,RequestMethod.GET})
    public Map<String,Object> saveUser(User user)throws Exception{
        Map<String,Object> map=new HashMap<String,Object>();
        if(userService.save(user) != null&&user.getId()!=null){
            map.put("msg","新增成功");
            map.put("state","200");
            map.put("user",user);
        }else{
            map.put("msg","新增失败");
            map.put("state","500");
        }
        return map;
    }
}

• 自此全部搞定。如果你不想千篇一律的写不用实现Jpa和JDBC的业务接口，你可以编写成代码模板，根据代码模板生成代码！这一块我就不说了！

---

现在小猿同学终于可以安心去出家了！！！就在小猿同学准备再次出家的时候，口袋的手机响了！！经理打电话来说：“小猿啊，系统的菜单加载好慢啊，你给想想办法给搞搞啊！！”