SpringBoot持久化層操作支持技巧

更新時(shí)間：2017年10月13日 10:35:51 作者：晉文子上的博客

這篇文章主要介紹了SpringBoot持久化層操作支持技巧,需要的朋友可以參考下

SpringBoot的持久化層可以是Spring內(nèi)置的輕量級(jí)JdbcTemplate、也可以是Hibernate或Mybatis等等，只需要在在工程pom.xml文件中添加對(duì)應(yīng)的依賴就可以了。

新建工程我們能發(fā)現(xiàn)，SpringBoot對(duì)數(shù)據(jù)庫(kù)操作的支持有以下幾種：

可見SpringBoot對(duì)各種的支持還是挺多的。

入正題。看看對(duì)SQL的支持。主要選了比較傳統(tǒng)/流行/有前景的4個(gè)進(jìn)行操作：

均是采用mysql。

所以應(yīng)該添加對(duì)mysql操作的依賴：

<!--MySQL-->
<dependency>
  <groupid>mysql</groupid>
  mysql-connector-java</artifactid>
  <scope>runtime</scope>
</dependency>

同時(shí)，需要對(duì)web進(jìn)行支持，添加web相關(guān)依賴

<!--web支持-->
<dependency>
  <groupid>org.springframework.boot</groupid>
  spring-boot-starter-web</artifactid>
</dependency>

需要在application.properties中配置mysql相關(guān)信息（也可以使用*.yml）。配置如下：

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url= jdbc:mysql://localhost:3306/springboottest?useUnicode=true&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=root

實(shí)際應(yīng)用的時(shí)候，需要添加數(shù)據(jù)庫(kù)連接池，為了方便，就暫時(shí)不添加了。

1. SpringBoot用JdbcTemplates訪問Mysql

首先需要添加對(duì)JdbcTemplates的依賴，可以在新建工程中點(diǎn)擊添加，或手動(dòng)添加

<!--JDBC支持-->
<dependency>
  <groupid>org.springframework.boot</groupid>
  spring-boot-starter-jdbc</artifactid>
</dependency>

目錄結(jié)構(gòu)如上，代碼如下：

@Data
public class Account {
  private int id ;
  private String name ;
  private double money;
}

這里是安裝了一個(gè)插件，然后只需要添加如下依賴，添加@Data注解，就會(huì)幫我們自動(dòng)生成getter和setter，也可以用@getter或@Setter注解進(jìn)行標(biāo)注。

<dependency>
  <groupid>org.projectlombok</groupid>
  lombok</artifactid>
</dependency>

Dao層：

public interface IAccountDao {
  int add(Account account);
  int update(Account account);
  int delete(int id);
  Account findAccountById(int id);
  Account selectAccountById(int id);
 
  List findAccountList();
}</account>

實(shí)現(xiàn)類：

@Repository
public class AccountDaoImpl implements IAccountDao{
 
  @Autowired private JdbcTemplate jdbcTemplate;
 
  @Override
  public int add(Account account) {
    return jdbcTemplate.update("INSERT INTO account(name,money) VALUES(?,?)",
        account.getName(),account.getMoney());
  }
 
  @Override
  public int update(Account account) {
    return jdbcTemplate.update("UPDATE account SET name=?,money=? WHERE id=?",
        account.getName(),account.getMoney(),account.getId());
  }
 
  @Override
  public int delete(int id) {
    return jdbcTemplate.update("DELETE FROM TABLE account WHERE id=?", id);
  }
 
  @Override
  public Account findAccountById(int id) {
    List list = jdbcTemplate.query("SELECT * FROM account WHERE id = ?",
        new Object[]{id}, new BeanPropertyRowMapper(Account.class));
    if(list!=null && list.size()>0){
      Account account = list.get(0);
      return account;
    }else{
      return null;
    }
  }
  @Override
  public Account selectAccountById(int id){
 
    return jdbcTemplate.queryForObject("SELECT * FROM account WHERE id = ?", new RowMapper() {
      @Override
      public Account mapRow(ResultSet resultSet, int i) throws SQLException {
        Account account = new Account();
        account.setId(resultSet.getInt("id"));
        account.setName(resultSet.getString("name"));
        account.setMoney(resultSet.getDouble("money"));
        return account;
      }
    },id);
  }
 
  @Override
  public List findAccountList() {
    List list = jdbcTemplate.query("SELECT * FROM account",
        new Object[]{}, new BeanPropertyRowMapper(Account.class));
    if(list!=null && list.size()>0) return list;
    else return null;
  }
}</account></account></account></account>

后續(xù)也可以添加更多的操作，包括分頁(yè)等等。這里主要就是jdbcTemplate的操作了，詳情也可以查相關(guān)資料

Service層：

public interface IAccountService {
  int add(Account account);
  int update(Account account);
  int delete(int id);
  Account findAccountById(int id);
  Account selectAccountById(int id);
  List findAccountList();
}</account>

實(shí)現(xiàn)

@Service
public class JdbcAccountService implements IAccountService {
  @Autowired private IAccountDao accountDao;
 
  @Override
  public int add(Account account) {
    return accountDao.add(account);
  }
 
  @Override
  public int update(Account account) {
    return accountDao.update(account);
  }
 
  @Override
  public int delete(int id) {
    return accountDao.delete(id);
  }
 
  @Override
  public Account findAccountById(int id) {
    return accountDao.findAccountById(id);
  }
 
  @Override
  public Account selectAccountById(int id) {
    return accountDao.selectAccountById(id);
  }
 
  @Override
  public List findAccountList() {
    return accountDao.findAccountList();
  }
}
</account>

Controller：

@RestController
@RequestMapping("/jdbc/account")
public class JdbcAccountController {
 
  @Autowired private IAccountService accountService;
 
  @RequestMapping(value = "/list",method = RequestMethod.<em>GET</em>)
  public List getAccounts(){
    return accountService.findAccountList();
  }
 
  @RequestMapping(value = "/{id}",method = RequestMethod.<em>GET</em>)
  public Account getAccountById(@PathVariable("id") int id){
//    return accountService.findAccountById(id);
    return accountService.selectAccountById(id);
  }
 
  @RequestMapping(value = "/{id}",method = RequestMethod.<em>PUT</em>)
  public String updateAccount(@PathVariable("id")int id ,
                 @RequestParam(value = "name",required = true)String name,
                 @RequestParam(value = "money",required = true)double money){
    Account account=new Account();
    account.setMoney(money);
    account.setName(name);
    account.setId(id);
    int t=accountService.update(account);
    if(t==1){
      return account.toString();
    }else {
      return "fail";
    }
  }
 
  @RequestMapping(value = ""/*,method = RequestMethod.POST*/)
  public String postAccount( @RequestParam(value = "name")String name,
                @RequestParam(value = "money")double money){
    Account account=new Account();
    account.setMoney(money);
    account.setName(name);
    int t= accountService.add(account);
    if(t==1){
      return account.toString();
    }else {
      return "fail";
    }
  }
}</account>

難度不大，只是簡(jiǎn)單的對(duì)數(shù)據(jù)庫(kù)進(jìn)行訪問和修改，注意注解不要忘記標(biāo)注了。

2.SpringBoot 整合JPA

Jpa算是比較方便的，用起來只需注意相關(guān)規(guī)則就可以了，不管jpa還是mybatis，都是有各自優(yōu)點(diǎn)的，在那里使用方便，就采用哪個(gè)，沒好壞之分。

首先，也是需要添加相關(guān)的依賴

<!--JPA支持-->
<dependency>
  <groupid>org.springframework.boot</groupid>
  spring-boot-starter-data-jpa</artifactid>
</dependency>

創(chuàng)建實(shí)體（注意注解）

Dao層：這里只做了簡(jiǎn)單的演示，所以沒有添加特殊的操作，直接繼承jpa給我們提供的接口，就可以了，后續(xù)需要添加一些東西的話，可以添加對(duì)應(yīng)的方法

public interface AccountDao extends JpaRepository {
}</account,integer>

Controller層：

@RestController
@RequestMapping("/jpa/account")
public class JpaAccountController {
 
 @Autowired private AccountDao accountDao;
 
 @RequestMapping(value = "/list",method = RequestMethod.<em>GET</em>)
 public List getAccounts(){
  return accountDao.findAll();
 }
 
 @RequestMapping(value = "/{id}",method = RequestMethod.<em>GET</em>)
 public Account getAccountById(@PathVariable("id") int id){
  return accountDao.findOne(id);
 }
 
 @RequestMapping(value = "/{id}",method = RequestMethod.<em>PUT</em>)
 public String updateAccount(@PathVariable("id")int id ,
         @RequestParam(value = "name",required = true)String name,
         @RequestParam(value = "money",required = true)double money){
  Account account=new Account();
  account.setMoney(money);
  account.setName(name);
  account.setId(id);
  Account account1 = accountDao.saveAndFlush(account);
  return account1.toString();
 }
 
 @RequestMapping(value = ""/*,method = RequestMethod.POST*/)
 public String postAccount( @RequestParam(value = "name")String name,
        @RequestParam(value = "money")double money){
  Account account=new Account();
  account.setMoney(money);
  account.setName(name);
 
  Account account1 = accountDao.save(account);
  return account1.toString();
 }
}</account>

總體來說，jpa代碼很簡(jiǎn)潔，也很強(qiáng)大，能夠?qū)崿F(xiàn)一些常規(guī)的操作，對(duì)于開發(fā)者來說還是挺高效的，對(duì)于一些特殊的需求，也可以看官方給我們的文檔，3.springboot整合mybatisMybatis在現(xiàn)在也是一個(gè)非常流行的持久化層框架了，和Hibernate比起來，可以自己編寫sql語(yǔ)句，從而利用高效的sql語(yǔ)句制作好的產(chǎn)品。但缺點(diǎn)也是在編寫sql語(yǔ)句，這方面有點(diǎn)花時(shí)間，相比jpa來說。入正題：

添加依賴：

<!--MyBatis支持-->
<dependency>
 <groupid>org.mybatis.spring.boot</groupid>
 mybatis-spring-boot-starter</artifactid>
 <version>1.2.0</version>
</dependency>

Mybatis可以采用兩種方式進(jìn)行編寫，一種是基于xml的配置方式，一種是基于注解的方式，選擇何種方式，當(dāng)然是蘿卜白菜啦，選最合適自己的。

實(shí)體還是上一個(gè)例子的實(shí)體，這里就不添加了，dao層設(shè)計(jì)我們先來說一下用注解的方式：注解的方式相比下還是挺方便的，

@Mapper
public interface AccountMapper {
 @Insert("INSERT INFO account(name,money) VALUES(#{name},#{money})")
 int add(@Param("name")String name,
   @Param("money")double money);
 
 @Update("UPDATE account SET name = #{name}, money = #{money} WHERE id = #{id}")
 int update(@Param("name") String name, @Param("money") double money, @Param("id") int id);
 
 @Delete("DELETE FROM account WHERE id = #{id}")
 int delete(int id);
 
 @Select("SELECT id, name AS name, money AS money FROM account WHERE id = #{id}")
 Account findAccount(@Param("id") int id);
 
 @Select("SELECT id, name AS name, money AS money FROM account")
 List findAccountList();
}
</account>

注解單詞簡(jiǎn)單明了，就不解釋了，但要注意的是，方法名稱也要適當(dāng)?shù)娜『?，不然以后?duì)數(shù)據(jù)庫(kù)操作多了，有可能會(huì)亂，需要不斷回來看代碼。

Service層：

@Service
public class MybatisAccountService {
 
 @Autowired private AccountMapper accountMapper;
 
 public int add(String name, double money) {
  return accountMapper.add(name, money);
 }
 public int update(String name, double money, int id) {
  return accountMapper.update(name, money, id);
 }
 public int delete(int id) {
  return accountMapper.delete(id);
 }
 public Account findAccount(int id) {
  return accountMapper.findAccount(id);
 }
 public List findAccountList() {
  return accountMapper.findAccountList();
 }
}</account>

對(duì)應(yīng)的Controller與上面的沒有多大區(qū)別

@RestController
@RequestMapping("/mybatis/account")
public class MybatisAccountController {
 
 @Autowired private MybatisAccountService mybatisAccountService;
 @RequestMapping(value = "/list", method = RequestMethod.<em>GET</em>)
 public List getAccounts() {
  return mybatisAccountService.findAccountList();
 }
 @RequestMapping(value = "/{id}", method = RequestMethod.<em>GET</em>)
 public Account getAccountById(@PathVariable("id") int id) {
  return mybatisAccountService.findAccount(id);
 }
 @RequestMapping(value = "/{id}", method = RequestMethod.<em>PUT</em>)
 public String updateAccount(@PathVariable("id") int id,
        @RequestParam(value = "name", required = true) String name,
        @RequestParam(value = "money", required = true) double money) {
  int t= mybatisAccountService.update(name,money,id);
  if(t==1) {
   return "success";
  }else {
   return "fail";
  }
 }
 @RequestMapping(value = "/{id}", method = RequestMethod.<em>DELETE</em>)
 public String delete(@PathVariable(value = "id")int id) {
  int t= mybatisAccountService.delete(id);
  if(t==1) {
   return "success";
  }else {
   return "fail";
  }
 }
 @RequestMapping(value = "", method = RequestMethod.<em>POST</em>)
 public String postAccount(@RequestParam(value = "name") String name,
        @RequestParam(value = "money") double money) {
  int t= mybatisAccountService.add(name,money);
  if(t==1) {
   return "success";
  }else {
   return "fail";
  }
 }
 
}</account>

對(duì)比之下，我們?cè)賮砜纯椿趚ml的配置方式。（偷懶就只做一個(gè)了）

public interface AccountMapper1 {
 int update(@Param("money") double money, @Param("id") int id);
}

首先需要寫一個(gè)接口，然后在application中添加配置

mybatis.mapper-locations=classpath*:mybatis/*Mapper.xml
mybatis.type-aliases-package=com.jinwen.www.MYBATIS.bean

很簡(jiǎn)單，然后編寫主要的sql語(yǔ)句了，由于我們的配置，后綴名必須為Mapper.xml才可以被掃描到

需要在resources下創(chuàng)建一個(gè)mybaits文件夾，并添加xml，這里我們明明為AccountMapper.xml.，代碼如下

<!--?xml version="1.0" encoding="UTF-8"?-->
 
<mapper namespace="com.jinwen.www.MYBATIS.Dao.AccountMapper1">
 <update id="update">
  UPDATE account set money=#{money} WHERE id=#{id}
 </update>
</mapper>

注意，命名空間那里，需要填自己的，簡(jiǎn)單的一個(gè)update，做完這幾步，就可以了

service層：

@Service
public class MybatisAccountService1 {
 @Autowired AccountMapper1 accountMapper1;
 @Transactional
 public void transfer() throws RuntimeException{
  accountMapper1.update(90,1);//用戶1減10塊 用戶2加10塊
//  int i=1/0;//測(cè)試事務(wù)回滾
  accountMapper1.update(110,2);
 }
}

@Transactional注解可以實(shí)現(xiàn)事務(wù)回滾，當(dāng)發(fā)生異常的時(shí)候，同樣，對(duì)于jpa，jdbcTemplate也可以添加此注解進(jìn)行事務(wù)處理。

Controller層（這里注意的是@MapperScan的注解，是實(shí)體的路徑）

@RestController
@RequestMapping("/mybatis/account")
@MapperScan("com.jinwen.www.MYBATIS.Dao")
public class MybatisAccountController1 {
 @Autowired private MybatisAccountService1 accountService;
 @RequestMapping(value = "/transfer", method = RequestMethod.<em>GET</em>)
 public void transfer(){
  accountService.transfer();
 }
}

mybatis更多復(fù)雜的操作可以想見相關(guān)的mybatis資料。4.springboot整合 BeetlSQL

BeetlSQL 特點(diǎn)

BeetSql是一個(gè)全功能DAO工具，同時(shí)具有Hibernate 優(yōu)點(diǎn) & Mybatis優(yōu)點(diǎn)功能，適用于承認(rèn)以SQL為中心，同時(shí)又需求工具能自動(dòng)能生成大量常用的SQL的應(yīng)用。

開發(fā)效率無(wú)需注解，自動(dòng)使用大量?jī)?nèi)置SQL，輕易完成增刪改查功能，節(jié)省50%的開發(fā)工作量數(shù)據(jù)模型支持Pojo，也支持Map/List這種快速模型，也支持混合模型SQL 模板基于Beetl實(shí)現(xiàn)，更容易寫和調(diào)試，以及擴(kuò)展可以針對(duì)單個(gè)表(或者視圖）代碼生成pojo類和sql模版，甚至是整個(gè)數(shù)據(jù)庫(kù)。能減少代碼編寫工作量維護(hù)性SQL 以更簡(jiǎn)潔的方式，Markdown方式集中管理，同時(shí)方便程序開發(fā)和數(shù)據(jù)庫(kù)SQL調(diào)試?？梢宰詣?dòng)將sql文件映射為dao接口類靈活直觀的支持支持一對(duì)一，一對(duì)多，多對(duì)多關(guān)系映射而不引入復(fù)雜的OR Mapping概念和技術(shù)。具備Interceptor功能，可以調(diào)試，性能診斷SQL，以及擴(kuò)展其他功能其他內(nèi)置支持主從數(shù)據(jù)庫(kù)支持的開源工具支持跨數(shù)據(jù)庫(kù)平臺(tái)，開發(fā)者所需工作減少到最小，目前跨數(shù)據(jù)庫(kù)支持mysql,postgres,oracle,sqlserver,h2,sqllite,DB2. 以上來自beatlSql官網(wǎng)文檔。網(wǎng)址：https://ibeetl.com/guide/#beetlsql

總體指標(biāo)比起來，比mybatis更具備優(yōu)勢(shì)，或?qū)⒊蔀槲磥淼闹髁鳌?/p>

首先需要添加依賴

<!--beetlsql支持-->
<groupid>com.ibeetl</groupid>
beetlsql</artifactid>
<version>2.9.5</version>

然后要在主方法類下進(jìn)行配置（很關(guān)鍵，不然會(huì)報(bào)一些找不到的錯(cuò)誤，或者一些奇怪的錯(cuò)誤）

@SpringBootApplication
public class SpringbootpersistenceApplication {
 public static void main(String[] args) {
  SpringApplication.run(SpringbootpersistenceApplication.class, args);
 }
 
 //配置包掃描
 @Bean(name = "beetlSqlScannerConfigurer")
 public BeetlSqlScannerConfigurer getBeetlSqlScannerConfigurer() {
  BeetlSqlScannerConfigurer conf = new BeetlSqlScannerConfigurer();
  conf.setBasePackage("com.jinwen.www.BeetlSQL.Dao");
  conf.setDaoSuffix("Dao");
  conf.setSqlManagerFactoryBeanName("sqlManagerFactoryBean");
  return conf;
 }
 
 @Bean(name = "sqlManagerFactoryBean")
 @Primary
 public SqlManagerFactoryBean getSqlManagerFactoryBean(@Qualifier("datasource") DataSource datasource) {
  SqlManagerFactoryBean factory = new SqlManagerFactoryBean();
 
  BeetlSqlDataSource source = new BeetlSqlDataSource();
  source.setMasterSource(datasource);
  factory.setCs(source);
  factory.setDbStyle(new MySqlStyle());
  factory.setInterceptors(new Interceptor[]{new DebugInterceptor()});
  factory.setNc(new UnderlinedNameConversion());//開啟駝峰
  factory.setSqlLoader(new ClasspathLoader("/sql"));//sql文件路徑
  return factory;
 }
 
 //配置數(shù)據(jù)庫(kù)
 @Bean(name = "datasource")
 public DataSource getDataSource() {
  return DataSourceBuilder.create().url("jdbc:mysql://localhost:3306/springboottest").username("root").password("root").build();
 }
 
// //開啟事務(wù)
// @Bean(name = "txManager")
// public DataSourceTransactionManager getDataSourceTransactionManager(@Qualifier("datasource") DataSource datasource) {
// DataSourceTransactionManager dsm = new DataSourceTransactionManager();
// dsm.setDataSource(datasource);
// return dsm;
// }
 
}

注意這里的配置包掃描，需要掃描自己的包，不然會(huì)包no find

根據(jù)配置，編寫的“sql”代碼將在sql路徑下，需要在resources下創(chuàng)建這個(gè)文件夾

編寫相關(guān)操作

實(shí)體：

@Data
public class Account {
 private int id ;
 private String name ;
 private double money;
}

dao層：

@SqlResource("account")
public interface BeetlSQLAccountDao extends BaseMapper {
// @SqlStatement(params = "name")
 Account selectAccountByName(String name);
}
</account>

@SqlResource注解就是在sql目錄下對(duì)應(yīng)的.md文件。如果是java.account則對(duì)應(yīng)是sql目錄下的java目錄下的account.md文件。這個(gè)文件寫有相關(guān)的對(duì)數(shù)據(jù)庫(kù)的操作。

注意，這里繼承的BaseMapper是由BeetlSQL提供的。

account.md 編寫

<em>selectAccountByName
</em><em>===
</em>*根據(jù)name獲account
 select * from account where name= #name#

Controller層：

@RestController
@RequestMapping("/beetlsql/account")
public class BeetlSQLAccountController {
 
 @Autowired private BeetlSQLAccountDao beetlSQLAccountDao;
 
 @RequestMapping(value = "/list",method = RequestMethod.<em>GET</em>)
 public List getAccounts(){
  return beetlSQLAccountDao.all();
 }
 @RequestMapping(value = "/{id}",method = RequestMethod.<em>GET</em>)
 public Account getAccountById(@PathVariable("id") int id){
  return beetlSQLAccountDao.unique(id);
 }
 @RequestMapping(value = "",method = RequestMethod.<em>GET</em>)
 public Account getAccountById(@RequestParam("name") String name){
  return beetlSQLAccountDao.selectAccountByName(name);
 }
 @RequestMapping(value = "/{id}",method = RequestMethod.<em>PUT</em>)
 public String updateAccount(@PathVariable("id")int id , @RequestParam(value = "name",required = true)String name,
         @RequestParam(value = "money" ,required = true)double money){
  Account account=new Account();
  account.setMoney(money);
  account.setName(name);
  account.setId(id);
  int t= beetlSQLAccountDao.updateById(account);
  if(t==1){
   return account.toString();
  }else {
   return "fail";
  }
 }
 @RequestMapping(value = "",method = RequestMethod.<em>POST</em>)
 public String postAccount( @RequestParam(value = "name")String name,
        @RequestParam(value = "money" )double money) {
  Account account = new Account();
  account.setMoney(money);
  account.setName(name);
  KeyHolder t = beetlSQLAccountDao.insertReturnKey(account);
  if (t.getInt() > 0) {
   return account.toString();
  } else {
   return "fail";
  }
 }
 
}</account>

注意：SpringBoot沒有提供BeetlSQL的@Transactional支持，需要自己添加事務(wù)的支持，上面被注釋的代碼中有編寫到