利用反射和动态代理实现DAO接口的默认CRUD实现(类似Sprng JPA)

最新推荐文章于 2021-12-02 10:31:38 发布
最新推荐文章于 2021-12-02 10:31:38 发布
阅读量434 收藏 3
点赞数
分类专栏： java菜鸟笔记 文章标签： java

本文来自 fair-jm.iteye.com 转截请注明出处

 

用了下JPA对于其方便的操作很好奇 通过继承CRUDRepository等接口 DAO不用写实现类就可以在注入后实现基本的增删改查功能

 

搜索到了一些内容:

http://my.oschina.net/xdev/blog/126049 这里有一些实现的原理 比较详细

http://sunting-bcwl.iteye.com/blog/768989 代码实现如何获得泛型等内容

 

 

实现很简单 用了JPA和java的动态代理以及反射

基本的结构

有一个CRUD的接口:

package jdbc;

import java.util.List;

public interface CRUD<T,I> {

	public List<T> query();
	
	public T findOne(I id);
	
	public void delete(I id);
	
	public void add(T t);
	
	public int update(T t);
}

 此接口是所有DAO的接口必须继承的

 

 

 实践中用了两个DAO user和item

 这里以User为例

User的代码如下:

package com.cc.proxy.test.domain;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="user")
public class User {

	@Id
	private int uid;
	private String name;
	private int sex;
	private String description;
	private int age;
	//省略getter和setter
	
}

   UserDao:

package com.cc.proxy.test.dao;

import com.cc.proxy.test.domain.User;

import jdbc.CRUD;

public interface UserDao extends CRUD<User,Integer> {

}

   

通过代理User就可以使用CRUD等方法(我实际上就写了query和add 其他方法在代理的invoke中补充就可以了):

   

 

=================================================================================

=================================================================================

 

接下去是最主要的代理类的代码:

代理类ProxyDao(实现InvocationHandler)的属性如下:

	private String tableName=null; //表名
	
	private Class entity=null;   //实体类
	private Class idType=null;  //id类型
	
	private String id=null;  //id在实体类中的属性名(方便操作)
	//filed<--->column
	private Map<String,String> columMapping=new HashMap<>();

 

构造方法:

	public ProxyDao(Class dao) throws Exception{
		if(!check(dao)){
			throw new Exception("not a dao");
		}
	}

 其中check方法是完成DAO的检查

这里的检查主要包括:

  1. DAO是否继承了CRUD接口
  2. CRUD接口上的泛型是否是实体(有无@Entity和@Id)

代码如下:

	private boolean check(Class dao) throws Exception{
		 boolean hasCRUD=false;
		 //检查是否继承了CRUD接口 没有的话就返回false
		 for(Class inter:dao.getInterfaces()){
			 if(inter==CRUD.class){
				 hasCRUD=true;
				 break;
			 }
		 }
		 if(!hasCRUD){
			 return false;
		 }
		 //取得第一个接口的信息 这里也就是CRUD接口
		 Type t=dao.getGenericInterfaces()[0];
		 //获得CRUD的泛型 第一个是对应的实体类 第二个是对应的id类型
		 entity=(Class)((ParameterizedType)t).getActualTypeArguments()[0];
		 idType=(Class)((ParameterizedType)t).getActualTypeArguments()[1];
		 
		 Annotation[] as=entity.getAnnotations();
		 //检查是否有Entity这个annotation没有则退出
		 boolean hasEntity=false;
	       for(Annotation a:as){
	    	  if(a.annotationType()==javax.persistence.Entity.class){
	    		  hasEntity=true;
	    	  }
	    	  if(a.annotationType()==javax.persistence.Table.class){
	    		  tableName=((javax.persistence.Table)a).name();
	    	  }
	       }
	       if(!hasEntity){
	    	   return false;
	       }
	       //如果table的name没有值 那么用实体类的类名就可以了
	       if(tableName==null){
	    	   tableName=entity.getSimpleName();
	       }
	       
	       boolean hasId=false;
			Field[] fs=entity.getDeclaredFields();
			for(Field f:fs){
				if(f.getAnnotation(Id.class)!=null){
					id=f.getName();
					hasId=true;
				}
				//这里建立 属性<-->字段名的映射
				if(f.getAnnotation(Column.class)!=null){
					columMapping.put(f.getName(), f.getAnnotation(Column.class).name());
				}else{
					columMapping.put(f.getName(),f.getName());
				}
			}
	       if(!hasId){
	    	   return false;
	       }
	       return true;
	}

 

最后就是invoke方法了，invoke完成运行方法的指派:

	public static final String QUERY="select * from %s ";
	public static final String ADD="insert into %s(%s) values (%s)";
	public static final String DELETE="delete from %s where %s=?";
	public static final String FIND="select * from %s where %s=?";
	public static final String UPDATE="update %s set %s where %s=?";
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		if(method.getName().equals("query")){
			List list=new ArrayList<>();
			try(Connection conn=DBConnection.getConnection()){
				PreparedStatement pst=conn.prepareStatement(String.format(QUERY, tableName));
				ResultSet rs=pst.executeQuery();
				while(rs.next()){
					Object o=entity.newInstance();
					for(Field f:entity.getDeclaredFields()){
						f.setAccessible(true);
						f.set(o, rs.getObject(columMapping.get(f.getName()),f.getType()));
					}
					list.add(o);
				}
			}
			return list;
		}
		
		if(method.getName().equals("add")){
			Object o=args[0];
			StringBuffer arg=new StringBuffer();
			StringBuffer values=new StringBuffer();
			for(Field f:entity.getDeclaredFields()){
				if(f.getName().equals(id)){ //id不用自己插入
					continue;
				}
				f.setAccessible(true);
				if(f.get(o)!=null){
				  arg.append(columMapping.get(f.getName())).append(",");
				  values.append(String.format("'%s'", f.get(o))).append(",");
				}
			}
//			arg.substring(0,arg.length()-1);
//			values.substring(0,values.length()-1);
			try(Connection conn=DBConnection.getConnection()){
				PreparedStatement pst=conn.prepareStatement(String.format(ADD, tableName,arg.substring(0,arg.length()-1),values.substring(0,values.length()-1)));
				  pst.execute();
				}
		}
		
				if(method.getName().equals("delete")){
			Object o=args[0];
			try(Connection conn=DBConnection.getConnection()){
				PreparedStatement pst=conn.prepareStatement(String.format(DELETE, tableName,id));
				pst.setObject(1, o);
				pst.execute();
			}
		}
		
		if(method.getName().equals("findOne")){
			Object o=args[0];
			try(Connection conn=DBConnection.getConnection()){
				PreparedStatement pst=conn.prepareStatement(String.format(FIND, tableName,id));
				pst.setObject(1, o);
				ResultSet rs=pst.executeQuery();
				if(rs.next()){
						Object ob=entity.newInstance();
						for(Field f:entity.getDeclaredFields()){
							f.setAccessible(true);
							f.set(ob, rs.getObject(columMapping.get(f.getName()),f.getType()));
						}
						return ob;
				}else{
					return null;
				}
			}
		}
		
		if(method.getName().equals("update")){
			Object o=args[0];
			Object idNumber=null;
			StringBuffer set=new StringBuffer();
			for(Field f:entity.getDeclaredFields()){
				f.setAccessible(true);
				if(f.getName().equals(id)){
					idNumber=f.get(o);
					continue;
				}
				if(f.get(o)!=null){
				  set.append(columMapping.get(f.getName())+"="+String.format("'%s'", f.get(o))).append(",");
				}
			}
			if(idNumber==null){
				return 0;
			}
			try(Connection conn=DBConnection.getConnection()){
				PreparedStatement pst=conn.prepareStatement(String.format(UPDATE, tableName,set.substring(0,set.length()-1),id));
				pst.setObject(1, idNumber);
				return pst.executeUpdate();
			}
		}
		
		return null;
	}

 不只是这些方法 对于UserDao如果有findOneByName这种方法 完全可以通过invoke方法进行分析和执行相应动作(这里可以用一个判断方法名是findOneBy开头的来 后面的属性放入SQL中就可以了)

 

代码中偷懒直接对属性用Field来取 实际中应该通过getter和setter来取和赋值 自己实验一下就怎么方便怎么写了

 

 

实现起来不是很难 就是一些基本的反射的操作和一些基础的逻辑判断

从前也未思考过动态代理有什么用(最多就是一些AOP的内容) 对于直接用来实现接口 压根就没想过..

写代码这种东西 总是能找到新的乐趣啊....

 

 

此外关于动态代理的其他的用法可以看:

http://www.infoq.com/cn/articles/cf-java-reflection-dynamic-proxy

infoQ里的内容挺不错的~~~

 

 

2013最后一篇博客了~~来年也要玩得开心^_^~~

fairjm
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于代理Dao实现CRUD操作
superfloat的博客
04-25 159
使用要求： 1、持久层接口和持久层接口的映射配置必须在相同的包下 2、持久层映射配置中mapper标签的namespace属性取值必须是持久层接口的全限定类名 3、sql语句的配置标签,,,的id属性必须和持久层接口的方法名相同 根据ID查询 1、 在持久层接口中添加findById方法 /** * 根据id查询用户信息 * @param userId * @...
利用反射创建的CRUD
06-20
利用反射创建的增删改查，保存时只需传入一个对象即可，不需要写配置文件。使用hjz.jar时，首先 Session s = new Session();然后执行数据库操作。
使用动态代理记录方法执行的时间
weixin_34218579的博客
04-22 151
      在大型系统中，我们经常需要监视我们系统执行的性能状况，当出现性能问题时，我们要能够迅速地找到瓶颈在什么地方。在程序的层面上来说，就是看哪个方法执行所消耗的时间很长。       使用动态代理可以非常方便的记录方法执行的时间，比如，下面的截图，就是ESBasic.Emit.Aop.Interceptors.MethodTimeInterceptor截获器记录的片段： 2009-4-1...
反射-动态代理的概述与其简单实现
Sherry
12-29 197
一.动态代理 代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。 举例：春节回家买票让人代买。 动态代理：在程序运行过程中产生的这个对象。而程序运行过程中产生对象其实就是我们之前学习反射学习的内容，所以回归本质，动态代理其实就是通过反射来生成一个代理。 二.相关的类和方法 类Proxy有个方法static Object newProxyInstance(ClassLoader l...
自定义注解+动态代理 模拟 Spring data jpa 的实现原理
qq_29767649的博客
05-24 1484
今天使用动态代理来模拟 Spring data jpa 的实现原理，从而让学习者更加理解动态代理； 好了，话不多说，直接看代码 自定义注解 package com.yonyou.learn.porxy; import java.lang.annotation.*; /** * 自定义注解 */ @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD}) @Documented public @interface .
使用反射实现万能DAO（基于JDBC）
nieguohui94的博客
09-15 533
1 没有利用反射来对数据库进行操作 创建工具类：JDBCConnection（使用单列设计模式） package com.test.connection; import java.sql.Connection; import java.sql.DriverManager; public class JDBCConnection { private static final String
Springboot和Jpa实现学生CRUD操作代码实例
08-19
Springboot和Jpa实现学生CRUD操作代码实例 Springboot和Jpa是目前非常流行的技术栈，广泛应用于企业级项目中。该篇文章主要介绍了使用Springboot和Jpa实现学生CRUD操作代码实例，通过详细的示例代码，帮助读者快速...
Java 中利用泛型和反射机制抽象DAO的实例
08-30
Java 中利用泛型和反射机制抽象DAO的实例 Java 中利用泛型和反射机制抽象DAO的实例是指在 Java 中使用泛型和反射机制来抽象出一个通用的DAO（Data Access Object），从而将DAO抽象到另一层次，提高代码的质量和可...
基于php和mysql的简单的dao类实现crud操作功能
10-26
首先，DAO类的主要目的是为数据库操作提供接口，它封装了SQL语句的构建和执行。在给出的代码中，`SimpleDao`类实现了这一目标。类中定义了一个私有的`$_table`变量来存储要操作的表名，以及一个静态的`$_con`变量来...
SpringBoot整合Jpa和Thymeleaf实现CRUD
08-11
SpringBoot整合Jpa和Thymeleaf实现CRUD是一个典型的Web开发应用场景，它结合了SpringBoot的便捷性、JPA的数据持久层处理以及Thymeleaf的模板引擎，旨在简化开发流程并提供高效的数据库操作。在这个项目中，我们可以...
Spring Data JPA ——默认方法使用
weixin_33859504的博客
09-08 1232
初探 SDJ 先让我们来巩固一下 Java 的基础知识。Java 是面向对象的语言，目的是解决现实生活中的问题，可以通过使用类来包装现实生活中的事物成对象、使用属性来描述对象的特点并使用方法来控制对象的行为。我们在 Java 里一切的操作都是针对对象本身，这也是为什么我们需要 ORM 来操作存储在数据库里面的“对象”。题外话，对于类似于 ...
基于反射与动态代理封装SQL实战（一）：整体框架介绍
广工最菜的琛
05-10 186
一 前言 （1）前言 最近在学习动态代理的时候，把使用动态代理封装数据库的操作当成一个练习来做。现在分享一下，也当成一个复习动态代理的机会。大家有什么好的想法、问题还是建议都可以在评论区指出。 完整源码在GitHub：https://github.com/attendent/distrubuted （2）实现的功能 介绍一下目前完成的部分以及后面会涉及到的博客内容： 可使用@AutoDao实现实...
【Mybatis】--Dao接口动态代理实现CRUD（增、删、改、查），以及动态SQL＜if＞、＜where＞、＜set＞、＜foreach＞标签以及分页实现的案例
NanYII_的博客
10-12 510
一、 项目介绍 1、Mybatis的Dao接口动态代理实现CRUD（增、删、改、查）案例 2、项目开发工具：    (1) jdk1.8.0_92    (2) mysql-5.5.45-winx64    (3) Navicat_for_MySQL_11.0.10    (4) IDEA-2019.3.4    (5) apache-maven-3.5.2
SpringDataJPA通过实现接口（代理的形式）进行简单的CRUD
qq_42041712的博客
07-02 1431
一 SpringDataJPA通过接口实现简单的CRUD操作 首先 需要在dao层实现JpaRepository ，JpaSpecificationExecutor接口 /* * 符合SpringDatajpa的dao层接口规范 *JpaRepository<操作的实体类类型，实体类中主键属性的类型> *封装了基本的CRUD操作 JpaSpecification...
代理模式（CGLib动态代理实现aop切面）——用AOP测试业务层方法的执行时间
weixin_30820151的博客
03-14 98
代理模式 对代理模式的理解，通过http://www.runoob.com/design-pattern/proxy-pattern.html 对AOP的代理模式，参考https://www.cnblogs.com/xujiming/p/5737531.html 目标：测试service层每一个方法的执行时间； 代理模式的本质：将被代理对象注入给代理对象，当调用代理对象时，实际上...
从spring jpa getone 说到 Hibernate中的动态代理Javassist
flyskyhunter的专栏
05-02 1864
上一章写到 时候谈到   personRepository.getOne(id) ，在调用 proxy-> aop ReflectiveMethodInvocation. proceed()   一系列的interceptorOrInterceptionAdvice 后，然后调用  SimpleJpaRepository.getOne（id）--> SessionImpl.load(class,i
使用aop、类反射机制、动态代理截获jpa标签@query内容实现适配器（实例）
weixin_44458631的博客
12-02 579
spring data jpa项目中使用aop、类反射机制、动态代理截获jpa标签@query内容并更改sql内容继续执行的例子。
利用反射写出通用DAO方法
weixin_30321449的博客
02-18 150
@Test public void testGet() { String sql = "select id,name,email,birth from customers where id=?"; int params = 1; Customer customer = get(Customer.class, sql, params); System.out.println(custom...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值