深入实践Spring Boot

```java
// 代码清单4-4 使用@Query自定义查询

@Repository
public interface UserRepository extends JpaRepository {
@Query("select t from User t where t.name =?1 and t.email =?2")
User findByNameAndEmail(String name, String email);
@Query("select t from User t where t.name like :name")
Page findByName(@Param("name") String name, Pageable pageRequest);
}
4.2.1　扩展JPA接口
首先创建一个接口，继承于JpaRepository，并将接口标记为@NoRepositoryBean，以防被当作一般的Repository调用，如代码清单4-5所示。接口ExpandJpaRepository不仅扩展了JPA原来的findOne、findAll、count等方法，而且增加了deleteByIds、get-EntityClass、nativeQuery4Map等方法，其中nativeQuery4Map用来执行原生的复杂的SQL查询语句。
代码清单4-5　扩展JPA接口定义
@NoRepositoryBean
public interface ExpandJpaRepository extends JpaRepository {
T findOne(String condition, Object... objects);
List findAll(String condition, Object... objects);
List findAll(Iterable predicates, Operator operator);
List findAll(Iterable predicates, Operator operator, Sort sort);
Page findAll(Iterable predicates, Operator operator, Pageable
pageable);
long count(Iterable predicates, Operator operator);
List findAll(String condition, Sort sort, Object... objects);
Page findAll(String condition, Pageable pageable, Object... objects);
long count(String condition, Object... objects);
void deleteByIds(Iterable ids);
Class getEntityClass();
List> nativeQuery4Map(String sql);
Page nativeQuery4Map(String sql, Pageable pageable);
Object nativeQuery4Object(String sql);
}
这一接口的所有声明方法，必须由我们来实现。为了节省篇幅，只列出实现的部分代码，如代码清单4-6所示。完整的代码可以通过检出实例工程查看。实现代码中使用了JPQL查询语言（Java Persistence Query Language），它是JPA的查询语句规范。
代码清单4-6　扩展JPA接口实现
public class ExpandJpaRepositoryImpl extends SimpleJpaRepository implements ExpandJpaRepository {
private final EntityManager entityManager;
private final JpaEntityInformation entityInformation;
public ExpandJpaRepositoryImpl(JpaEntityInformation entityInformation,
EntityManager entityManager) {
super(entityInformation, entityManager);
this.entityManager = entityManager;
this.entityInformation = entityInformation;
}
@Override
public T findOne(String condition, Object... values) {
if(isEmpty(condition)){
throw new NullPointerException("
条件不能为空
!");
}
T result = null;
try {
result = (T) createQuery(condition, values).getSingleResult();
} catch (NoResultException e) {
e.printStackTrace();
}
return result;
}
@Override
public List findAll(Iterable predicates, Operator operator) {
return new JpqlQueryHolder(predicates,operator).createQuery().getResult
List();
}
@Override
public List findAll(Iterable predicates, Operator operator, Sort sort) {
return new JpqlQueryHolder(predicates,operator,sort).createQuery().getResult
List();
}
@Override
public Page findAll(Iterable predicates, Operator operator, Pageable
pageable) {
if(pageable==null){
return new PageImpl((List) findAll(predicates,operator));
}
Long total = count(predicates,operator);
Query query = new JpqlQueryHolder(predicates,operator,pageable.getSort()).
createQuery();
query.setFirstResult(pageable.getOffset());
query.setMaxResults(pageable.getPageSize());
List content = total > pageable.getOffset() ? query.getResultList() :
Collections. emptyList();
return new PageImpl(content, pageable, total);
}
......
}
因为自定义的接口继承于JpaRepository，所以不但具有自定义的一些功能，而且拥有JPA原来的所有功能，它的继承关系如图4-3所示。
图4-3　扩展JPA接口的继承关系

图4-3　扩展JPA接口的继承关系
4.2.2　装配自定义的扩展接口
自定义的接口必须在程序启动时装配，才能正常使用。首先，创建一个装配类ExpandJpaRepository-FactoryBean，继承于JpaRepositoryFactory-Bean，用来加载自定义的扩展接口，如代码清单4-7所示。其中getTargetRepository返回自定义的接口实现：ExpandJpaRepositoryImpl。
代码清单4-7　JPA扩展接口装配类
public class ExpandJpaRepositoryFactoryBean, T, ID extends Serializable>
extends JpaRepositoryFactoryBean {
protected RepositoryFactorySupport createRepositoryFactory(
EntityManager entityManager) {
return new ExpandJpaRepositoryFactory(entityManager);
}
private static class ExpandJpaRepositoryFactory

extends JpaRepositoryFactory {
private final EntityManager entityManager;
public ExpandJpaRepositoryFactory(EntityManager entityManager) {
super(entityManager);
this.entityManager = entityManager;
}
protected Object getTargetRepository(RepositoryMetadata metadata) {
JpaEntityInformation entityInformation = (JpaEntity
Information) getEntityInformation(metadata.getDomainType());
return new ExpandJpaRepositoryImpl(entityInformation, entity
Manager);
}
protected Class getRepositoryBaseClass(RepositoryMetadata metadata) {
return ExpandJpaRepositoryImpl.class;
}
}
}
然后，在JPA配置类中，通过@EnableJpaRepositories加载定义的装配类ExpandJpa-RepositoryFactoryBean，如代码清单4-8所示。其中，“com.**.repository”为定义接口的资源库路径，“com.**.entity”为实体模型的路径。
代码清单4-8　JPA配置类
@Order(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@EnableTransactionManagement(proxyTargetClass = true)
@EnableJpaRepositories(basePackages = "com.**.repository",repositoryFactoryBeanClass = ExpandJpaRepositoryFactoryBean.class)
@EntityScan(basePackages = "com.**.entity")
public class JpaConfiguration {
@Bean
PersistenceExceptionTranslationPostProcessor persistenceExceptionTranslationPostProcessor(){
return new PersistenceExceptionTranslationPostProcessor();
}
}
4.2.3　使用扩展接口
现在来做实体的持久化，这样就可以直接使用自定义的扩展接口了。如代码清单4-9所示，资源库接口UserRepository继承的就是前面定义的接口ExpandJpaRepository。
代码清单4-9　使用扩展接口做持久化
@Repository
public interface UserRepository extends ExpandJpaRepository {
@Query("select t from User t where t.name =?1 and t.email =?2")
User findByNameAndEmail(String name, String email);
@Query("select t from User t where t.name like :name")
Page findByName(@Param("name") String name, Pageable pageRequest);
}
使用JPA扩展接口与使用原来的JPA接口一样，调用方法基本相同，只不过有些方法被赋予更为丰富的功能，可以更加灵活地使用。代码清单4-10是一个使用扩展接口的分页查询，使用PredicateBuilder来构造一个查询参数的对象，它可以包含更多的查询参数。
代码清单4-10　使用扩展JPA接口的分页查询
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
public Page findPage(UserQo userQo){
Pageable pageable = new PageRequest(userQo.getPage(), userQo.getSize(),
new Sort(Sort.Direction.ASC, "id"));
PredicateBuilder pb  = new PredicateBuilder();
if (!StringUtils.isEmpty(userQo.getName())) {
pb.add("name","%" + userQo.getName() + "%", LinkEnum.LIKE);
}
if (!StringUtils.isEmpty(userQo.getCreatedateStart())) {
pb.add("createdate",userQo.getCreatedateStart(), LinkEnum.GE);
}
if (!StringUtils.isEmpty(userQo.getCreatedateEnd())) {
pb.add("createdate",userQo.getCreatedateEnd(), LinkEnum.LE);
}
return userRepository.findAll(pb.build(), Operator.AND, pageable);
}
}
4.3　使用Redis做缓存
在数据库使用中，数据查询是最大的性能开销。如果能借助Redis作为辅助缓存，将可以极大地提高数据库的访问性能。使用Redis做缓存，一方面可以像第2章介绍的使用Redis那样调用，另一方面，可以使用注解的方式来调用，这种方式更加简单，代码也更加简洁。
需要注意的是，Redis是一个具有持久化功能的数据库系统，若使用默认配置，存取的数据就会永久地保存在磁盘中。如果只是使用Redis来做缓存，并不需要Redis永久保存数据，可以设定在Redis保存数据的期限来实现，这样，过期的数据将自动从Redis数据库中清除。这不但能很好地利用Redis的快速存取功能，而且能彻底减轻Redis的负担。作为缓存使用的数据，最初就是从数据库中查询出来的，所以完全没有必要再做一次永久保存。始终让Redis保持轻装上阵，才能最好地发挥它的性能优势。
4.3.1　使用Spring Cache注解
结构简单的对象，即没有包含其他对象的实体，可以使用Spring Cache注解的方式来使用Redis缓存。要使用注解的方式调用缓存，必须在配置类中启用Spring Cache，如代码清单4-11所示。其中setDefaultExpiration指定了数据在Redis数据库中的有效期限。
代码清单4-11　Spring Cache配置
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
@Bean
public CacheManager cacheManager(@SuppressWarnings("rawtypes") RedisTemplate
redisTemplate) {
RedisCacheManager manager = new RedisCacheManager(redisTemplate);
manager.setDefaultExpiration(43200);// 12
小时
return manager;
}
}
这样，就可以在对数据接口的调用中，对增删查改加入如代码清单4-12所示的注解，自动增加缓存的创建、修改和删除等功能。其中注解@Cacheable为存取缓存，注解@CachePut为修改缓存，如果不存在则创建，注解@CacheEvict为删除缓存，当删除数据时，如果缓存还存在，就必须删除，各个注解中的value参数是一个key的前缀，并由keyGenerator按一定的规则生成一个唯一标识。
代码清单4-12　用注解方式使用Redis做缓存
@Service
public class RoleService {
@Autowired
private RoleRepository roleRepository;
@Autowired
private RoleRedis roleRedis;
@Cacheable(value = "mysql:findById:role", keyGenerator = "simpleKey")
public Role findById(Long id) {
return roleRepository.findOne(id);
}
@CachePut(value = "mysql:findById:role", keyGenerator = "objectId")
public Role create(Role role) {
return roleRepository.save(role);
}
@CachePut(value = "mysql:findById:role", keyGenerator = "objectId")
public Role update(Role role) {
return roleRepository.save(role);
}
@CacheEvict(value = "mysql:findById:role", keyGenerator = "simpleKey")
public void delete(Long id) {
roleRepository.delete(id);
}
......
}
对于key的生成规则，使用如代码清单4-13所示的方法来实现，这里主要使用了调用者本身对象的ID属性来保证它的唯一性，其中simpleKey和objectId都是提取调用者本身的类名字和参数id作为唯一标识。
代码清单4-13　生成cache的key
@Bean
public KeyGenerator simpleKey(){
return new KeyGenerator() {
@Override
public Object generate(Object target, Method method, Object... params) {
StringBuilder sb = new StringBuilder();
sb.append(target.getClass().getName()+":");
for (Object obj : params) {
sb.append(obj.toString());
}
return sb.toString();
}
};
}
@Bean
public KeyGenerator objectId(){
return new KeyGenerator() {
@Override
public Object generate(Object target, Method method, Object... params){
StringBuilder sb = new StringBuilder();
sb.append(target.getClass().getName()+":");
try {
sb.append(params[0].getClass().getMethod("getId", null).
invoke(params[0], null).toString());
}catch (NoSuchMethodException no){
no.printStackTrace();
}catch(IllegalAccessException il){
il.printStackTrace();
}catch(InvocationTargetException iv){
iv.printStackTrace();
}
return sb.toString();
}
};
}
4.3.2　使用RedisTemplate
由于使用Spring Cache注解的方法使用Redis缓存，只能对简单对象进行系列化操作，所以对于像实体User这样的包含了一定关系的复杂对象，或其他集合、列表对象等，就不能使用简单注解的方法来实现了，还要像第2章中介绍的方法那样使用RedisTemplate来调用Redis，其使用的效果和上面使用Cache注解的效果相同，只不过实现方法完全不同。
代码清单4-14使用RedisTemplate实现了对Redis的调用。这种方式可以很方便地对列表对象进行系列化，在数据存取时使用Json进行格式转换。这里使用分钟作为时间单位来设定数据在Redis中保存的有效期限。
代码清单4-14　使用RedisTemplate
@Repository
public class UserRedis {
@Autowired
private RedisTemplate redisTemplate;
public void add(String key, Long time, User user) {
Gson gson = new Gson();
redisTemplate.opsForValue().set(key, gson.toJson(user), time, TimeUnit.
MINUTES);
}
public void add(String key, Long time, List users) {
Gson gson = new Gson();
redisTemplate.opsForValue().set(key, gson.toJson(users), time, TimeUnit.
MINUTES);
}
public User get(String key) {
Gson gson = new Gson();
User user = null;
String json = redisTemplate.opsForValue().get(key);
if(!StringUtils.isEmpty(json))
user = gson.fromJson(json, User.class);
return user;
}
public List getList(String key) {
Gson gson = new Gson();
List ts = null;
String listJson = redisTemplate.opsForValue().get(key);
if(!StringUtils.isEmpty(listJson))
ts = gson.fromJson(listJson, new TypeToken>(){}.getType());
return ts;
}
public void delete(String key){
redisTemplate.opsForValue().getOperations().delete(key);
}
}
然后编写如代码清单4-15所示的代码来使用Redis缓存。即在使用原来数据库的增删查改过程中，同时使用Redis进行辅助存取，以达到提升访问速度的目的，从而缓解对原来数据库的访问压力。这样，访问一条数据时，首先从Redis读取，如果存在则不再到MySQL中读取，如果不存在再到MySQL读取，并将读取的结果暂时保存在Redis中。
代码清单4-15　在数据服务中使用Redis作为辅助缓存
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
@Autowired
private UserRedis userRedis;
private static final String keyHead = "mysql:get:user:";
public User findById(Long id) {
User user = userRedis.get(keyHead + id);
if(user == null){
user = userRepository.findOne(id);
if(user != null)
userRedis.add(keyHead + id, 30L, user);
}
return user;
}
public User create(User user) {
User newUser = userRepository.save(user);
if(newUser != null)
userRedis.add(keyHead + newUser.getId(), 30L, newUser);
return newUser;
}
public User update(User user) {
if(user != null) {
userRedis.delete(keyHead + user.getId());
userRedis.add(keyHead + user.getId(), 30L, user);
}
return userRepository.save(user);
}
public void delete(Long id) {
userRedis.delete(keyHead + id);
userRepository.delete(id);
}
上面使用Redis缓存的两种方法，可以在一个应用中混合使用。但不管怎么使用，对于控制器来说都是完全透明的，控制器对数据接口的调用还是像以前一样，它并不清楚数据接口后端是否启用了缓存，如代码清单4-16所示。
代码清单4-16　控制器使用数据接口
@Autowired
private UserService userService;
@RequestMapping(value="/{id}")
public String show(ModelMap model,@PathVariable Long id) {
User user = userService.findById(id);
model.addAttribute("user",user);
return "user/show";
}
使用缓存之后，大量的查询语句就从原来的数据库服务器中，转移到了高效的Redis服务器中执行，这将在很大程度上减轻原来数据库服务器的压力，并且提升查询的反应速度和效率。所以在很大的程度上，系统性能就得到了很好的改善。
4.4　Web应用模块
对于上面一些功能的实现，最后使用一个Web应用来调用，以验证使用Druid连接池和使用Redis缓存的效果，同时可以体验使用JPA扩展接口更为丰富的功能。
4.4.1　引用数据管理模块
实例工程中的Web应用模块将引用数据管理模块，而数据管理模块使用了第2章实例工程中MySQL模块的实体-关系模型设计，即使用部门、用户和角色三个实体，如图4-4所示。实体的建模还与第2章中使用的方法一样，没有做任何修改。至于实体的持久化，如前所述，只要在原来的持久化中改变资源库接口定义中继承于自定义的扩展接口即可。
图4-4　实体-关系模型设计

图4-4　实体-关系模型设计
4.4.2　Web应用配置
Web应用的界面设计使用第3章的设计来实现。这里，主要实现对部门、用户和角色三个实体的数据进行增删查改的管理。
在Web应用模块的配置文件application.yml中，配置连接MySQL和Redis服务器的一些参数，如代码清单4-17所示。
代码清单4-17　Web应用配置
server:
port: 80
tomcat:
uri-encoding: UTF-8
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql:// localhost:3306/test?characterEncoding=utf8
username: root
password: 12345678
#
初始化大小，最小，最大
initialSize: 5
minIdle: 5
maxActive: 20
#
配置获取连接等待超时的时间
maxWait: 60000
#
配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
timeBetweenEvictionRunsMillis: 60000
#
配置一个连接在池中的最小生存时间，单位是毫秒
minEvictableIdleTimeMillis: 300000
validationQuery: SELECT 1 FROM DUAL
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
#
打开
PSCache
，并且指定每个连接上
PSCache
的大小
poolPreparedStatements: true
maxPoolPreparedStatementPerConnectionSize: 20
#
配置监控统计拦截的
filters
，去掉后监控界面
SQl
将无法统计，
'wall'
用于防火墙
filters: stat,wall,log4j
#
通过
connectProperties
属性来打开
mergeSql
功能；慢
SQL
记录
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
#
合并多个
DruidDataSource
的监控数据
#useGlobalDataSourceStat=true
jpa:
database: MYSQL
show-sql: true
## Hibernate ddl auto (validate|create|create-drop|update)
hibernate:
ddl-auto: update
naming-strategy: org.hibernate.cfg.ImprovedNamingStrategy
properties:
hibernate:
dialect: org.hibernate.dialect.MySQL5Dialect
## redis
redis:
host: 192.168.1.214
port: 6379
pool:
max-idle: 8
min-idle: 0
max-active: 8
max-wait: -1
启动应用后，运行效果如图4-5所示。除了分页数据没有做缓存之外，其他查询都做了缓存处理。在控制台上可以看到执行的SQL查询语句，一个查询，比如查看用户，如果在控制台上没有看到输出查询语句，就可以说明是调用了Redis缓存。
关于使用缓存的情况，也可以登录安装Redis的服务器，使用下列指令，查看当前所有的key。
#redis-cli
>keys *
下载一个Redis客户端，可以更加直观地查看Redis服务器的情况，如图4-6所示。
图4-5　Web应用运行效果

图4-5　Web应用运行效果
图4-6　Redis客户端

图4-6　Redis客户端
4.5　运行与发布
本章实例的完整代码可以直接在IDEA中通过GitHub检出：https://github.com/chen-fromsz/spring-boot-dbup.git。
检出工程后，可以运行Web应用模块website进行测试。在IDEA的Run/Configura-tion中增加一个Spring Boot配置，模块选择website，工作目录选择website模块所在的路径，主程序选择com.test.website.WebApplication，并将配置保存为webapp。
在MySQL服务器中创建一个数据库：test，配置Web应用模块website的配置文件application.yml中连接MySQL服务器的url、username、password，以及Redis的host和port。然后运行配置项目webapp，启动完成后，在浏览器中打开网址：http://127.0.0.1。
注意　因为localhost不能加入Druid的监控服务器的白名单中，所以使用localhost可能不能正常访问。而使用域名的方式是可以的，只要把域名所指向的IP加入Druid的白名单中即可。
如果要打包发布，可以在IDEA的Run/Configuration中增加一个Maven配置项目，工作目录选择工程根目录spring-boot-dbup所在的路径，在命令行中输入指令clean package，然后将配置项目保存为mvn。或者直接打开一个命令行窗口，切换到工程根目录所在路径，执行下列Maven指令：
mvn clean package
打包完成后，在命令行窗口中切换到模块website的target目录中，输入下列指令可运行应用：
java
–
jar website-1.0-SNAPSHOT.jar
4.6　小结
本章使用Druid连接池和Redis数据库作为缓存，提升了关系型数据库的访问性能，并且通过扩展全局的JPA接口，丰富了资源库的调用功能。
对于大数据时代的互联网应用来说，要从根本上提升数据库的性能，主要还在于数据库本身的设计和配置上，例如使用分布式设计的集群系统，通过合理的配置和组装，可以达到横向扩展的目的，以后通过增加设备的方式，可以随时扩充数据库的容量和提高其访问性能。
有了完备的数据库访问功能和漂亮的操作界面之后，一个应用中更重要的设计就是安全设计了。下一章将介绍使用Spring Security来为一个应用实现安全设计，从而实现用户认证和权限管理方面的功能。