将自定义注释建议应用于Spring Data JPA存储库 [英] Applying custom annotation advice to spring data jpa repository
问题描述
我正在研究mysql主从复制.我正在使用spring data jpa(spring boot).
I am working on a mysql master slave replication. I am using spring data jpa(spring boot).
我需要的是进入主服务器的所有写操作，以及要在多个只读从属设备之间平均分配的只读操作.
What I needed is all write operations to go to master server and read-only operations to be equally distributed among multiple read-only slaves.
为此，我需要:
使用特殊的JDBC驱动程序:com.mysql.jdbc.ReplicationDriver
Use special JDBC driver: com.mysql.jdbc.ReplicationDriver
在URL中设置复制::
Set replication: in the URL:
spring:
datasource:
driverClassName: com.mysql.jdbc.ReplicationDriver
url: jdbc:mysql:replication://127.0.0.1:3306,127.0.0.1:3307/MyForum?user=root&password=password&autoReconnect=true
test-on-borrow: true
validation-query: SELECT 1
database: MYSQL
需要关闭自动提交.(*)连接需要设置为只读.
Auto commit needs to be turned off. (*) Connection needs to be set to read-only.
为确保将JDBC连接设置为只读，我创建了一个注释和一个简单的AOP拦截器.
To ensure JDBC Connection is set to read-only, I created an annotation and a simple AOP interceptor.
注释
package com.xyz.forum.replication;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Created by Bhupati Patel on 02/11/15.
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ReadOnlyConnection {
}
拦截器
package com.xyz.forum.replication;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.hibernate.Session;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.persistence.EntityManager;
/**
* Created by Bhupati Patel on 02/11/15.
*/
@Aspect
@Component
public class ConnectionInterceptor {
private Logger logger;
public ConnectionInterceptor() {
logger = LoggerFactory.getLogger(getClass());
logger.info("ConnectionInterceptor Started");
}
@Autowired
private EntityManager entityManager;
@Pointcut("@annotation(com.xyz.forum.replication.ReadOnlyConnection)")
public void inReadOnlyConnection(){}
@Around("inReadOnlyConnection()")
public Object proceed(ProceedingJoinPoint pjp) throws Throwable {
Session session = entityManager.unwrap(Session.class);
ConnectionReadOnly readOnlyWork = new ConnectionReadOnly();
try{
session.doWork(readOnlyWork);
return pjp.proceed();
} finally {
readOnlyWork.switchBack();
}
}
}
以下是我的春季数据存储库
Following is my spring data repository
package com.xyz.forum.repositories;
import com.xyz.forum.entity.Topic;
import org.springframework.data.repository.Repository;
import java.util.List;
/**
* Created by Bhupati Patel on 16/04/15.
*/
public interface TopicRepository extends Repository<Topic,Integer>{
Topic save(Topic topic);
Topic findByTopicIdAndIsDeletedFalse(Integer topicId);
List<Topic> findByIsDeletedOrderByTopicOrderAsc(Boolean isDelete);
}
以下是我的Manager(Service)类.
Following is my Manager(Service) class.
package com.xyz.forum.manager;
import com.xyz.forum.domain.entry.impl.TopicEntry;
import com.xyz.forum.domain.exception.impl.AuthException;
import com.xyz.forum.domain.exception.impl.NotFoundException;
import com.xyz.forum.entity.Topic;
import com.xyz.forum.replication.ReadOnlyConnection;
import com.xyz.forum.repositories.TopicRepository;
import com.xyz.forum.utils.converter.TopicConverter;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
/**
* Created by Bhupati Patel on 16/04/15.
*/
@Repository
public class TopicManager {
@Autowired
TopicRepository topicRepository;
@Transactional
public TopicEntry save(TopicEntry topicEntry) {
Topic topic = TopicConverter.fromEntryToEntity(topicEntry);
return TopicConverter.fromEntityToEntry(topicRepository.save(topic));
}
@ReadOnlyConnection
public TopicEntry get(Integer id) {
Topic topicFromDb = topicRepository.findByTopicIdAndIsDeletedFalse(id);
if(topicFromDb == null) {
throw new NotFoundException("Invalid Id", "Topic Id [" + id + "] doesn't exist ");
}
return TopicConverter.fromEntityToEntry(topicFromDb);
}
}
在上面的代码中，@ ReadOnlyConnection批注在管理器或服务层中指定.上面的代码对我来说很好用.在服务层中，我仅从从数据库中读取数据并写入主数据库中.
In the above code @ReadOnlyConnection annotation is specified in manager or service layer. Above pieces of code works fine for me. It is a trivial case where in the service layer I am only reading from slave db and writing into master db.
已经说过我的实际要求是我应该能够在存储库级别本身中使用@ReadOnlyConnection，因为我有很多业务逻辑要在其他服务层中同时进行读/写操作，因此我不能将@ReadOnlyConnection放入服务层.
Having said that my actual requirement is I should be able to use @ReadOnlyConnection in repository level itself because I have quite a few business logic where I do both read/write operation in other classes of service layer.Therefore I can't put @ReadOnlyConnection in service layer.
我应该可以使用这样的东西
I should be able to use something like this
public interface TopicRepository extends Repository<Topic,Integer>{
Topic save(Topic topic);
@ReadOnlyConnection
Topic findByTopicIdAndIsDeletedFalse(Integer topicId);
@ReadOnlyConnection
List<Topic> findByIsDeletedOrderByTopicOrderAsc(Boolean isDelete);
}
就像spring的@Transactional或@Modifying或@Query注释一样.以下是我所指的示例.
Like spring's @Transactional or @Modifying or @Query annotation. Following is an example of what I am referring.
public interface AnswerRepository extends Repository<Answer,Integer> {
@Transactional
Answer save(Answer answer);
@Transactional
@Modifying
@Query("update Answer ans set ans.isDeleted = 1, ans.deletedBy = :deletedBy, ans.deletedOn = :deletedOn " +
"where ans.questionId = :questionId and ans.isDeleted = 0")
void softDeleteBulkAnswers(@Param("deletedBy") String deletedBy, @Param("deletedOn") Date deletedOn,
@Param("questionId") Integer questionId);
}
我对Aspectj和AOP世界是新手，我在ConnectionInterceptor中尝试了很多切入点的正则表达式，但是它们都不起作用.我已经尝试了很久了，但是还没有运气.
I am novice to aspectj and aop world, I tried quite a few pointcut regex in the ConnectionInterceptor but none of them worked. I have been trying this since a long time but no luck yet.
如何完成所要求的任务.
How to achieve the asked task.
推荐答案
我无法获得在方法级别使用自定义注释@ReadOnlyConnection(如@Transactional)的解决方法，但是有一点点帮助对我有用.
I couldn't get a workaround of having my custom annotation @ReadOnlyConnection(like @Transactional) at a method level,but a small heck did work for me.
我要粘贴下面的代码段.
I am pasting the code snippet below.
@Aspect
@Component
@EnableAspectJAutoProxy
public class ConnectionInterceptor {
private Logger logger;
private static final String JPA_PREFIX = "findBy";
private static final String CUSTOM_PREFIX = "read";
public ConnectionInterceptor() {
logger = LoggerFactory.getLogger(getClass());
logger.info("ConnectionInterceptor Started");
}
@Autowired
private EntityManager entityManager;
@Pointcut("this(org.springframework.data.repository.Repository)")
public void inRepositoryLayer() {}
@Around("inRepositoryLayer()")
public Object proceed(ProceedingJoinPoint pjp) throws Throwable {
String methodName = pjp.getSignature().getName();
if (StringUtils.startsWith(methodName, JPA_PREFIX) || StringUtils.startsWith(methodName, CUSTOM_PREFIX)) {
System.out.println("I'm there!" );
Session session = entityManager.unwrap(Session.class);
ConnectionReadOnly readOnlyWork = new ConnectionReadOnly();
try{
session.doWork(readOnlyWork);
return pjp.proceed();
} finally {
readOnlyWork.switchBack();
}
}
return pjp.proceed();
}
}
所以在上面的代码中，我使用了类似以下的切入点
So in the above code I am using a pointcut like following
@Pointcut("this(org.springframework.data.repository.Repository)")
public void inRepositoryLayer() {}
它的作用是
代理实现Repository接口的任何连接点(仅在Spring AOP中是方法执行)
any join point (method execution only in Spring AOP) where the proxy implements the Repository interface
您可以看一下 http://docs.spring.io/spring/docs/current/spring-framework-reference/html/aop.html
现在我所有的存储库读取查询方法都以前缀"findByXXX"(默认的spring-data-jpa可读方法)或"readXXX"(带有@Query注释的自定义读取方法)开头，在我的around方法执行中，以上切入点.根据我的要求，我将JDBC连接设置为true.
Now all my repository read query methods either start with a prefix "findByXXX"(default spring-data-jpa readable method) or "readXXX"(custom read method with @Query annotation) which in my around method executions matched by the above pointcut. According to my requirement I am setting the JDBC Connection readOnly true.
Session session = entityManager.unwrap(Session.class);
ConnectionReadOnly readOnlyWork = new ConnectionReadOnly();
我的ConnectionReadOnly如下所示
And my ConnectionReadOnly look like following
package com.xyz.forum.replication;
import org.hibernate.jdbc.Work;
import java.sql.Connection;
import java.sql.SQLException;
/**
* Created by Bhupati Patel on 04/11/15.
*/
public class ConnectionReadOnly implements Work {
private Connection connection;
private boolean autoCommit;
private boolean readOnly;
@Override
public void execute(Connection connection) throws SQLException {
this.connection = connection;
this.autoCommit = connection.getAutoCommit();
this.readOnly = connection.isReadOnly();
connection.setAutoCommit(false);
connection.setReadOnly(true);
}
//method to restore the connection state before intercepted
public void switchBack() throws SQLException{
connection.setAutoCommit(autoCommit);
connection.setReadOnly(readOnly);
}
}
因此上述设置可以满足我的要求.
So above settings work for my requirement.
这篇关于将自定义注释建议应用于Spring Data JPA存储库的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
