前言:最近忙着赶着一个金融项目,感受良多,整个项目使用的是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
简直是爽到爆
感谢前辈们不吝赐教的分享!
好了,继续学习去啦,activeMq,Dubbo,zookeeper都是最近项目架构中用到但都不太明白的东西,有兴趣的童鞋可以一起学习啊!