Example explanation of how to implement BaseDao in Java

The following editor will bring you a simple BaseDao example using custom annotations and reflection in Java. The editor thinks it’s pretty good, so I’ll share it with you now and give it as a reference. Let’s follow the editor and take a look.

In common ORM frameworks, most of them provide annotation methods to achieve mapping between entities and databases. Here we simply use custom annotations and reflection to generate executable sql. statement.

This is the overall directory structure. It was originally a project created for reviewing annotations^.^

Okay, first let's determine the idea.

1. Customize the @Table @Column annotation,

We slightly imitate hibernate and let @Table act on the class to indicate the entity The mapping relationship between the class and the data table, and let the attribute value in @Table be mapped to the name of the data table tableName; let @Column act on the attribute (the set method is not implemented here) to indicate the mapping between the attribute and the data table field relationship, and let the attribute value in @Column be mapped to a columnName of a field in the data table.

2. We need to imitate a Dao layer.

At this time we first define an entity User with name and password attributes, and then define A UserDao. There is a save (User user) method in UserDao. When we instantiate a UserDao and User, we call the save method of UserDao, pass in our User object, and return a section of sql. For this sql, we simply set it Set as "insert into user (name,password) VALUES('cai','123456')", where user is the name of our data table, name,password are data table fields,'cai','123456' are User objects properties.

--------------------------------0.0 code dividing line-------- -------------------------------------

//Column .java

package com.shu.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Column {
 String value();
}

//Table.java

package com.shu.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Table {
 String value();
 
}

//User.java

package com.shu.entity;
import com.shu.annotation.Column;
import com.shu.annotation.Table;

@Table("t_user")
public class User {
 
 @Column("name")
 private String name;
 @Column("password")
 private String password;
 
 public String getName() {
  return name;
 }
 public String getPassword() {
  return password;
 }
 public void setName(String name) {
  this.name = name;
 }
 public void setPassword(String password) {
  this.password = password;
 }
 
}

//IBaseDao.java

package com.shu.dao;
import java.lang.reflect.Field;

import com.shu.annotation.Column;
import com.shu.annotation.Table;

public interface IBaseDao<T> {
 
 //最终目标：insert into user (NAME,password) VALUES(&#39;cai&#39;,&#39;123456&#39;);
 default String save(T entity) throws IllegalArgumentException, IllegalAccessException{
  //sql用于存放最终返回的sql语句
  StringBuilder sql = new StringBuilder("insert into ");
  //tableName用于存放sql语句中表名部分
  StringBuilder tableName;
  //columnName用于存放sql语句的字段部分
  StringBuilder columnName = new StringBuilder("(");
  //values用于存放sql语句中的赋值部分
  StringBuilder values = new StringBuilder("(");
  //获取对象user的class对象
  Class clazz = entity.getClass();
  //判断该User类是否有@Table注解
  boolean isTable = clazz.isAnnotationPresent(Table.class);
  if(isTable) {
   //获取User类@Table注解的值value，该值我们定义为User表的表名称
   Table t = (Table) clazz.getAnnotation(Table.class);
   tableName = new StringBuilder(t.value());
   //拼接表名
   sql.append(tableName+" ");
   //获取user对象的属性列表
   Field[] fieldList = clazz.getDeclaredFields();
   //遍历属性列表，分别拿出属性列表中被@Column注解的属性，并获取属性的值
   for(int i=0;i<fieldList.length;i++){
    Field f = fieldList[i];
    boolean isColumn = f.isAnnotationPresent(Column.class);
    if(!isColumn){
     continue;
    }
    Column column = f.getAnnotation(Column.class);
     f.setAccessible(true); 
    Object columnValue = f.get(entity);
    if(i==fieldList.length-1){
     columnName.append(column.value()+") VALUES ");
     values.append("&#39;"+columnValue+"&#39;)");
     sql.append(columnName);
     sql.append(values);
     continue;
    }
    columnName.append(column.value()+", ");
    values.append("&#39;"+columnValue+"&#39;,");
   }
   
//   boolean isColumn = clazz.isAnnotationPresent(annotationClass);
  }
  return sql.toString();
 }


}

//UserDao.java

##

package com.shu.dao;

import com.shu.entity.User;

public class UserDao implements IBaseDao<User> {

}

//UserService.java

package com.shu.service;
import com.shu.dao.UserDao;
import com.shu.entity.User;

public class UserService {
 
 public static void main(String[] args) {
  // TODO Auto-generated constructor stub

  UserDao userDao = new UserDao();
  User user = new User();
  user.setName("cai");
  user.setPassword("123456");
  try {
   System.out.println(userDao.save(user));
  } catch (IllegalArgumentException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalAccessException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 
}

--------------------------------0.0 code dividing line-------- ---------------------------------------------

Here we finally define A Service layer, let it call the dao layer and generate the corresponding sql statement. You can customize other Entities, such as Order in my directory, and then define an OrderDao to implement the IBaseDao interface, and define an OrderService to call the save method of OrderDao. Similarly SQL statements corresponding to the order table can be generated.

Here is a summary of the shortcomings:

1. Hibernate annotations can be used without assignment, so I think it is necessary to directly obtain the name of the table without assignment. Or the name of the field can be obtained using reflection.

2. Only the save method is used here, and the SQL statement is dynamically generated without interacting with the database. A factory can be packaged to provide a persistence method to execute the SQL statement.

3. The splicing of sql here is relatively rough. You can think about whether there are other more efficient methods.

The above is the detailed content of Example explanation of how to implement BaseDao in Java. For more information, please follow other related articles on the PHP Chinese website!