使用spring boot 整合spring jpa做基于restful风格的增删改查(maven ,mysql)

前言：最近忙着赶着一个金融项目，感受良多，整个项目使用的是spring boot，

基础架构使用的是Dubbo集成三台服务器，利用 Zookeeper分布式 集群（具体知之甚少，有兴趣的可以一起学习啊）

项目中底层的持久化使用的是spring jpa和jdbc（联合使用），废话不多说，让我们一起来领略spring data jpa的强大吧！

2.首先我们创建一个maven项目springTest

我这里使用的是STS（类似于eclipse，特别适合用来做spring boot的开发，很强大的一款工具哟）

创建一个Java项目然后convert to maven项目

下面贴出pom.xml的依赖包

<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>SpringTest</groupId>
	<artifactId>SpringTest</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.9.RELEASE</version>
		<relativePath />
	</parent>
	
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
	</properties>
	
	<dependencies>
		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <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>
        

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
	</dependencies>	
	
	<build>
		<sourceDirectory>src</sourceDirectory>
		<plugins>
			 
			<!--<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.7.0</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>-->

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

</project>

3.下面我们创建一个实体：

package cn.ycg.spring.jpa.entity;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQuery;
import javax.persistence.Table;


/**
*@description
*@author ycg
*@date Jan 13, 2018
*/
@Entity
@Table(name="user_test")
//@org.hibernate.annotations.Table(appliesTo="user_test",comment="用户测试表")
//@NamedQuery(name = "User.findByName", query = "select userName,passWord from User  where userName=?1")
public class User implements Serializable{

	
	private static final long serialVersionUID = 4054155860118698875L;
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	private Long id;
	
	//@Column(name="user_name")
	@Column(columnDefinition="varchar(50) comment '用户名'" )
	private String userName;
	
	//@Column(name="pass_word")
	@Column(columnDefinition="varchar(50) comment '密码'")
	private String passWord;

注：省略了set/get方法

4.下面建一个IUserJpaRepository（继承了jpa的 JpaRepository后面会重点讲下这个jpa的精髓）

package cn.ycg.spring.jpa.repository;

import java.util.List;

import javax.persistence.criteria.From;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import cn.ycg.spring.jpa.entity.User;

/**
*@description
*@author ycg
*@date Jan 14, 2018
*/
public interface IUserJpaRepository extends JpaRepository<User, Long>{
	
	public List<User> findByUserNameAndPassWord(String userName,String passWord);
	
	public List<User> findByUserName(String userName);
	
	@Query("from User where userName=:userName")
	public List<User> findByUserName1(@Param("userName") String userName);
	
	//nativeQuery配置查询的方式是否是本地查询，默认是false
	//所谓本地查询，就是使用原生的sql语句（根据数据库的不同，在sql的语法或结构方面可能有所区别）进行查询数据库的操作
	//entityName对应的实体的名字
	//@Query(value="select * from #{#entityName} where userName=?1",nativeQuery=true)
	@Query(value="select * from user_test where user_name=?1",nativeQuery=true)
	public List<User> findByUserName2(String userName);
	
	public User findById(Long id);
	

}

5.下面建IUserService

package cn.ycg.spring.jpa.service;

import java.util.List;

import cn.ycg.spring.jpa.entity.User;

/**
*@description
*@author ycg
*@date Jan 14, 2018
*/

public interface IUserService {
	//获取所有
	public List<User> findAll();
	
	//根据id获取用户
	public User getUserById(Long id);
	
	//根据id删除
	public void delete(Long id);
	
	//根据用户名查询
	public List<User> findByName(String userName);
	
	//保存
	public void saveUser(User user);
	
	//批量保存
	public void saveUserList(List<User> list);

}

6.实现类UserServiceImpl

package cn.ycg.spring.jpa.service.impl;

import java.util.List;

import javax.annotation.Resource;

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

import cn.ycg.spring.jpa.entity.User;
import cn.ycg.spring.jpa.repository.IUserJpaRepository;
import cn.ycg.spring.jpa.service.IUserService;

/**
*@description
*@author ycg
*@date Jan 14, 2018
*/
@Service
public class UserServiceImpl implements IUserService {
	
	@Resource
	private IUserJpaRepository usr;

	@Override
	public List<User> findAll() {
		
		return usr.findAll();
	}

	@Transactional
	@Override
	public void delete(Long id) {
         usr.delete(id);
	}

	@Override
	public List<User> findByName(String userName) {
		List<User> list1=usr.findByUserName1(userName);
		List<User> list2=usr.findByUserName2(userName);
		List<User> list3=usr.findByUserNameAndPassWord(userName, "123");
		System.out.println("list1:"+list1);
		System.out.println("list2:"+list2);
		System.out.println("list3:"+list3);
			
		return usr.findByUserName(userName);
	}

	@Transactional
	@Override
	public void saveUser(User user) {
		usr.save(user);
		
	}

	@Transactional
	@Override
	public void saveUserList(List<User> list) {
		usr.save(list);
		
	}

	@Override
	public User getUserById(Long id) {
		
		return usr.findOne(id);
	}

}

7.哈哈，下面来到有意思的controller层UserController

package cn.ycg.spring.jpa.controller;

import java.util.List;

import javax.annotation.Resource;

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import cn.ycg.spring.jpa.entity.User;
import cn.ycg.spring.jpa.service.IUserService;

/**
*@description
*@author ycg
*@date Jan 14, 2018
*/
@RestController
@RequestMapping(value="/users")
public class UserController {
	
	@Resource
	private IUserService userService;

	
	@RequestMapping(value="/add/{id}/{userName}/{passWord}")
	public User addUser(@PathVariable Long id, @PathVariable String userName,@PathVariable String passWord) {
		User user=new User();
		user.setId(id);
		user.setUserName(userName);
		user.setPassWord(passWord);
		userService.saveUser(user);
		return user;
	}
	
	@RequestMapping(value="/")
	public List<User> getUsers(){
		return userService.findAll();
	}
	
	@RequestMapping(value="/{id}")
	public User getUser(@PathVariable Long id) {
		return userService.getUserById(id);
	}
	
	@RequestMapping(value="/search/userName/{userName}")
	public List<User> getUserByUserName(@PathVariable String userName){
		List<User> list=userService.findByName(userName);
		return list;
	}
}

注：

我这里使用了@RestController而不是Controller母的是为了方便实现restful风格（如果用童 鞋想更细节的了解下restful风格的好处可以找下度娘，网上资料一大把）

8.接下来就是spring boot的配置啦（spring boot就是这么简单，少了xml文件的烦恼）

spring.jpa.show-sql = true
logging.level.org.springframework.data=DEBUG
spring.jpa.hibernate.ddl-auto=update
#spring.jpa.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect  
 


spring.datasource.url=jdbc:mysql://localhost:3306/demo
spring.datasource.username=root
spring.datasource.password=ycg123
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

注：具体配置都很简单，就是一个mysql的配置加上hibernate的配置

9.接下来我们看看spring boot神奇的main方法

package cn.ycg.spring.jpa;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;

/**
*@description
*@author ycg
*@date Jan 14, 2018
*/
@SpringBootApplication
public class SpringJpaApplication {
	
	public static void main(String[] args) {
		SpringApplication.run(SpringJpaApplication.class, args);
	}
 
}

简洁到爆，对吧！

10.下面我们直接启动这个main方法，在浏览器直接访问controller层就可以做增删改查啦

http://localhost:8080/users/

http://localhost:8080/users/add/小明//123

http://localhost:8080/users/delete/1

http://localhost:8080/users/2

http://localhost:8080/users/search/userName/小红

11. Spring data JPA 的功能

好了，现在我们来讲下jpa的强大：

Spring data JPA 提供给用户使用的，主要有以下几个接口：

Repository：仅仅是一个标识，表明任何继承它的均为仓库接口类，方便 Spring 自动扫描识别 

CrudRepository：继承 Repository ，实现了一组 CRUD 相关的方法 

PagingAndSortingRepository ：继承 CrudRepository ，实现了一组分页排序相关的方法 

JpaRepository ：继承 PagingAndSortingRepository ，实现一组 JPA 规范相关的方法 

JpaSpecificationExecutor ：比较特殊，不属于 Repository 体系，实现一组 JPA Criteria 查询相关的方法 。

这里重点讲下CrudRepository这个接口（其它的也类似啦）

public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID> {  
    <S extends T> S save(S entity);//保存  
   <S extends T> Iterable<S> save(Iterable<S> entities);//批量保存  
    T findOne(ID id);//根据id查询一个对象  
    boolean exists(ID id);//判断对象是否存在  
    Iterable<T> findAll();//查询所有的对象  
    Iterable<T> findAll(Iterable<ID> ids);//根据id列表查询所有的对象  
    long count();//计算对象的总个数  
    void delete(ID id);//根据id删除  
    void delete(T entity);//删除对象  
    void delete(Iterable<? extends T> entities);//批量删除  
    void deleteAll();//删除所有  
} 

是不是一目了然！

11.总结：

jpa里面封装了很多常用的功能，增删改查（还可以批量哦），分页，甚至还可以自己写原生的sql

简直是爽到爆

末：参考大牛的博客： http://blog.csdn.net/liuchuanhong1/article/details/52042477

http://www.cnblogs.com/chenpi/p/6357527.html

感谢前辈们不吝赐教的分享！

好了，继续学习去啦，activeMq，Dubbo,zookeeper都是最近项目架构中用到但都不太明白的东西，有兴趣的童鞋可以一起学习啊！