深入理解Java的Annotation系列-第五部分 使用注解编写ORM框架

一、什么是ORM？

    对象关系映射（英语：(Object Relational Mapping，简称ORM，或O/RM，或O/Rmapping），是一种程序技术，随着面向对象的软件开发方法发展而产生的。用来把对象模型表示的对象映射到基于S
Q L 的关系模型数据库结构中去，或者把表中的一条记录自动封装成对象。

         



采用ORM优势在于，程序员采用面向对象的方法来访问数据库，简化了编码，提高了开发速度，ORM自动完成类和表，属性名和字段名的映射。

    使用本ORM框架，在处理查询业务逻辑时，只要编写形如"from 类名"的SQL语句，就可以得到封装好的所查询所有结果的List集合，处理添加业务时，只要调用Add(obj)方法即可实现添加功能。其他的功能读者可自行添加。

二、整体思路

  1、自定义ORM注解，包含@Table和@Column。

   2、写一个类，解析注解信息，并存入Map对象

   3、实现查询和添加功能

   4、使用自定义的ORM框架，实现业务逻辑

   5、测试

三、具体实现

  1、整体架构

     


   2、建表并插入数据的SQL

       showdatabases;

       create database czf;

       use czf;

       create table stu(id int primary key,namevarchar(40),age int);

       insert into stuvalues(1,'czf',34),(2,'afeng',25);

       select * from stu;

       createtable teacher(tid int primary key,tname varchar(40),tage int);

       insertinto teacher values(1,'czf',34),(2,'afeng',25);

       insert into teacher(tid,tname,tage)values(3,'czf3',33);

        select * from teacher;

3、具体代码

                 第一部分  ORM部分代码的编写

   3.1 Table.java

     packagecn.com.bochy.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * 自定义注解，用于注解类名所对应的表名
 * @authorchenzhengfeng
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public
@interface Table {
      String value();//表名
}

3.2 Column.java

   package cn.com.bochy.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * 自定义注解，用于注解对象的属性名所对应的表的列名
 * @authorchenzhengfeng
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public
@interface Column {
   String value();//列名
}

3.3 OrmImpl.java

   package cn.com.bochy.orm;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import cn.com.bochy.annotation.Column;
import cn.com.bochy.annotation.Table;
/**
 * 解析注解信息，并存入Map中
 * @authorchenzhengfeng
 */
public
class OrmImpl {
    //用于存储类名对应的表名，其中key是类名，value是表名
    private Map<String,String>mapTable=newHashMap<String,String>();
    //用于属性名对应的表的字段名，其中key是属性名，value是字段名
    private Map<String,String>mapColumns=newHashMap<String,String>();
    public Map<String, String> getMapTable() {
       returnmapTable;
    }
    public
void setMapTable(Map<String, String>
mapTable) {
       this.mapTable =mapTable;
    }
    private  StringtableName="";
    public String getTableName() {
       returntableName;
    }
    public
void setTableName(String tableName) {
       this.tableName =tableName;
    }
    public Map<String, String> getMapColumns() {
       returnmapColumns;
    }
    public
void setMapColumns(Map<String, String>
mapColumns) {
       this.mapColumns =mapColumns;
    }
    /**
     * 解析实体类的注解信息，其中c1是实体类的类对象
     * @param c1
     */
public
void parseAnnotation(Class<?> c1) {
    Table
table=c1.getAnnotation(Table.class);
    tableName=table.value();//获取注解的表名
    mapTable.put(c1.getName(),tableName);//存入
    Field[] fields=c1.getDeclaredFields();//获取所有的属性名
    for(Fieldf:fields) {//遍历属性名
       if(!f.getName().equals("serialVersionUID")) {
           Column
c=f.getAnnotation(Column.class);
           mapColumns.put(f.getName(),c.value());//获取该属性名所对应的字段，并存入
       }
    }
}
}

3.4  OrmQuery.java

package cn.com.bochy.orm;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import cn.com.bochy.dbutil.DBHepler;
/**
 * 实现查询功能
 * @authorchenzhengfeng
 *
 */
public
class OrmQuery {
    DBHepler helper=new DBHepler();
    private
static OrmImpl orm=null;
    private
static String tableName="";
    private
static Map<String,String> mapColumns=null;//存储属性和字段对应关系的MAP
    private
static Map<String,String> mapTables=null;//存储类名和表名对应关系的MAP
    private Class<?>classc1;//查询对象的类对象
    /**
     * 通过构造方法实现初始化工作
     * @param c1
     */
    public OrmQuery(Class<?>c1) {
       this.classc1=c1;
        orm=new OrmImpl();
           orm.parseAnnotation(classc1);//解析要查询对象的注解信息
           tableName=orm.getTableName();
           mapColumns=orm.getMapColumns();
           mapTables=orm.getMapTable();
    }
    /**
     * 查询sql形如"from类名"格式的语句，并封装成List，其他的形式请读者自行添加
     * @param hql
     * @return
     */
    @SuppressWarnings("rawtypes")
    public List query(Stringhql){ 

        int
index=hql.indexOf("from");
        /**
         * 以下语句是从hql语句中截取类名
         */
        StringclassName="";//类名
        StringfullclassName="";//包含包名的类名
        Stringsql="";
        Stringhqlsub=hql.substring(index+5);//form的长度为4，再加上空格，所以为5
        className=hqlsub;
           //遍历mapTables，查找类名对应的表名
        for(Stringkey:mapTables.keySet()) {
           if(key.contains(className)) {
               tableName=mapTables.get(key);
               fullclassName=key;
              
           }
        }
        sql="select * from "+tableName;
     ResultSet rs=
helper.query(sql, null);
    List<Object>lists=new ArrayList<Object>();
        try {
           while(rs.next()) {         
              Class<?>c1=  Class.forName(fullclassName);  //查询对象的类对象    
              Objects=   
c1.newInstance();//创建一个查询对象
           Field[]fs=  
c1.getDeclaredFields();//获取该对象的所有属性
             for(Fieldf:fs) {//遍历属性
               String fname=
f.getName();//获取某个属性名
              StringsetMethod="set"+FirstBig(fname);//某个属性名对应的setter方法名
                   Method[] methods=c1.getDeclaredMethods();//获取该对象的所有方法
                   for(Methodm:methods) {//遍历方法
                       if(m.getName().equals(setMethod)) {//如果找到对应的方法
                          String columnName=mapColumns.get(fname);//属性名对应的字段名
      
                             m.invoke(s,rs.getObject(columnName));//执行该setter方法,给对象m赋值
                          break;
                       }
                   }
             }
              lists.add(s);//把对象存入列表
           }
       } catch (SQLException |ClassNotFoundException | InstantiationException | IllegalAccessExceptione) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       } catch(IllegalArgumentExceptione) {
           // TODO Auto-generatedcatch block
           e.printStackTrace();
       } catch (InvocationTargetExceptione) {
           // TODO Auto-generatedcatch block
           e.printStackTrace();
       }
      return
lists;  
    }
    //把第一个字符变为大写
    public String FirstBig(Stringstr) {
        returnstr.substring(0,1).toUpperCase()+str.substring(1);
    }
}
3.5  OrmAdd.java

package cn.com.bochy.orm;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import cn.com.bochy.dbutil.DBHepler;
/**
 * 实现ORM中的添加功能
 * @authorchenzhengfeng
*/
public
class OrmAdd {
    DBHepler helper=new DBHepler();
    private
static OrmImpl orm=null;
    private
static Map<String,String> mapColumns=null;
    private Class<?>classc1;//指定要添加的对象的类类型
    //通过构造方法初始化
    public OrmAdd(Class<?>c1) {
       this.classc1=c1;
        orm=new OrmImpl();
           orm.parseAnnotation(classc1);//解析注解信息
           mapColumns=orm.getMapColumns();//获取属性名和字段名的对应信息 
    }
    /**
     * 通过Java的反射机制结合注解信息实现添加功能
     * @param obj
     * @return
     */
   public
boolean add(Object obj) {
       //获取表名
     for(String key:mapTables.keySet()) {
     if(key.equals(obj.getClass().getName())) {
     tableName=mapTables.get(key);
     }
     }
       Method[] methods=
obj.getClass().getDeclaredMethods();//获取添加对象中所有的方法
       Field[] fileds=obj.getClass().getDeclaredFields();//获取添加对象中所有的属性
       String sqlColumn="";//用于拼接要添加表中所有的字段
       String sqlvalue="";//用于拼接要添加的所有值，用？代替
      List<Object> parmas=newArrayList<Object>();//存储要添加的所有值
       for(Fieldf:fileds)//遍历属性
       for(Methodm:methods) {//遍历方法
               //获取该属性对应的getter方法
           if(m.getName().equals("get"+FirstBig(f.getName()))) {      
               Object values1;
              try {
                  values1 =
m.invoke(obj);//调用该对象的getter方法
                  parmas.add(values1);//把添加的值存入列表       
                  sqlColumn+=mapColumns.get(f.getName())+",";
                  sqlvalue+="?,";
              } catch (IllegalAccessExceptione) {
                  // TODO Auto-generatedcatch block
                  e.printStackTrace();
              } catch (IllegalArgumentExceptione) {
                  // TODO Auto-generatedcatch block
                  e.printStackTrace();
              } catch (InvocationTargetExceptione) {
                  // TODO Auto-generatedcatch block
                  e.printStackTrace();
              }          
           }
       }
       sqlColumn=CutoutLastChar(sqlColumn);//把最后一个","去掉
       sqlvalue=CutoutLastChar(sqlvalue);//把最后一个","去掉
       String sql="insert into "+tableName+"("+sqlColumn+")"+"
values("+sqlvalue+")";
      Object[] param=parmas.toArray();//把集合列表转化为数组
    return
helper.noQuery(sql,
param); //调用helper对象中noQuery实现添加功能
   }
   /**
    * 去掉字符串最后一个字符
    * @param str
    * @return
    */
   public String CutoutLastChar(Stringstr) {
       returnstr.substring(0,str.length()-1);
   }
   /**
    * 把字符串的首字符变为大写
    * @param str
    * @return
    */
    public String FirstBig(Stringstr) {
        returnstr.substring(0,1).toUpperCase()+str.substring(1);
    }
}
3.6 DBHepler.java
package cn.com.bochy.dbutil;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
 * 简单的JDBC的封装
 * @authorchenzhengfeng
 *
 */
public
class DBHepler {
    private  Stringurl="jdbc:mysql://localhost:3306/czf";
    private  Stringuser="root";
    private  Stringpassword="root";
    public  Connectionconn=null;
    public  PreparedStatementpstmt=null;
    public  ResultSetrs=null;
   //1、得到连接对象
   public  ConnectiongetConnection(){
       try {
       Class.forName("com.mysql.jdbc.Driver");
       conn=DriverManager.getConnection(url,user,
password);
    } catch (ClassNotFoundExceptione) {
       // TODO Auto-generatedcatch block
       e.printStackTrace();
    } catch (SQLExceptione) {
       // TODO Auto-generatedcatch block
       e.printStackTrace();
    }
    return
conn; 
   }
   //2、关闭资源
   public 
void closeAll(){
       try {
       if(rs!=null){
              rs.close();
          }
          if(pstmt!=null){
              pstmt.close();
          }
          if(conn!=null){
              conn.close();
          }
    } catch (SQLExceptione) {
       // TODO Auto-generatedcatch block
       e.printStackTrace();
      
      
    }
   }
    //3、通用查询方法
   public  ResultSetquery(Stringsql,Object[]
param){
       try {
          getConnection();
       pstmt=conn.prepareStatement(sql);
       if(param!=null)
       for(inti=0;i<param.length;i++){
           pstmt.setObject(i+1,param[i]);
       }
       rs=pstmt.executeQuery();
    } catch (SQLExceptione) {
       // TODO Auto-generatedcatch block
       e.printStackTrace();
    }
      
       returnrs;
   }
   //4、通用非查询方法
   public 
boolean noQuery(String sql,Object[]param){
       getConnection();
       int
a=0;
       try {
       pstmt=conn.prepareStatement(sql);
       if(param!=null)
           for(inti=0;i<param.length;i++){
              pstmt.setObject(i+1,param[i]);
           }
       a=pstmt.executeUpdate();
    } catch (SQLExceptione) {
       // TODO Auto-generatedcatch block
       e.printStackTrace();
    }
       closeAll();
       if(a>0)
       return
true;
       else
          return
false;
   }
}
             第二部分  ORM应用

3.7  实体类Stu.java

package cn.com.bochy.entity;
import java.io.Serializable;
import cn.com.bochy.annotation.Column;
import cn.com.bochy.annotation.Table;
/**
 * 实体类
 * @author Administrator
 *
 */
@Table("stu")//通过注解，类Stu对应表stu
public
class Stu implements Serializable {
    private
static final
long serialVersionUID = 1L;
    @Column("id")//通过注解,属性名id对应字段名(列名)id
    private
int id;
   
public
int getId() {
       returnid;
    }
    public
void setId(intid) {
       this.id =id;
    }
public String getName() {
       returnname;
    }
    public
void setName(String name) {
       this.name =name;
    }
    public
int getAge() {
       returnage;
    }
    public
void setAge(intage) {
       this.age =age;
    }
    @Column("name")//通过注解,属性名name对应字段名(列名)name
private String name;
    @Column("age")//通过注解,属性名age对应字段名(列名)age
  private
int age;
  public Stu() {
    // TODO Auto-generatedconstructor stub
}
}
3.8 实体类Teacher.java

package cn.com.bochy.entity;
import java.io.Serializable;
import cn.com.bochy.annotation.Column;
import cn.com.bochy.annotation.Table;
@Table("teacher")//通过注解,类Teacher对应表teacher
public
class Teacher implements Serializable {
    private
static final
long serialVersionUID = 1L;
    @Column(value="tid")//通过注解,属性名id对应字段名(列名)tid
    private
int id;
   
public
int getId() {
       returnid;
    }
    public
void setId(intid) {
       this.id =id;
    }
public String getName() {
       returnname;
    }
    public
void setName(String name) {
       this.name =name;
    }
    public
int getAge() {
       returnage;
    }
    public
void setAge(intage) {
       this.age =age;
    }
    @Column("tname")//通过注解,属性名name对应字段名(列名)tname
private String name;
    @Column("tage")//通过注解,属性名age对应字段名(列名)tage
  private
int age;
  public Teacher() {
    // TODO Auto-generatedconstructor stub
}
}
3.9  具体业务逻辑类StuBiz.java

package cn.com.bochy.biz;
import java.util.ArrayList;
import java.util.List;
import cn.com.bochy.entity.Stu;
import cn.com.bochy.orm.OrmAdd;
import cn.com.bochy.orm.OrmQuery;
/**
 * 使用自定义ORM框架实现具体的业务逻辑
 * @authorchenzhengfeng
 */
public
class StuBiz {
       OrmQuery query=new OrmQuery(Stu.class);
       OrmAdd Add=new OrmAdd(Stu.class);
     @SuppressWarnings("rawtypes")
    List lists=new ArrayList();
  @SuppressWarnings({
"rawtypes" })
  /**
   * 查选业务逻辑
   * @return
   */
public List getAllStus(){
      String hql="from Stu";
      lists=query.query(hql);
      return
lists;
   }
  /**
   * 添加业务逻辑
   * @params
   * @return
   */
  public
boolean add(Stu s){
      return
Add.add(s);
   }
}
3.10 具体业务逻辑类TeacherBiz.java
package cn.com.bochy.biz;
import java.util.ArrayList;
import java.util.List;
import cn.com.bochy.entity.Stu;
import cn.com.bochy.entity.Teacher;
import cn.com.bochy.orm.OrmAdd;
import cn.com.bochy.orm.OrmQuery;
/**
 * 使用自定义ORM框架实现具体的业务逻辑
 * @authorchenzhengfeng
 *
 */
public
class TeacherBiz {
     OrmQuery query=newOrmQuery(Teacher.class);
     OrmAdd Add=new OrmAdd(Teacher.class);
     List<Stu>  lists=new ArrayList<Stu>();
  @SuppressWarnings({
"unchecked", "rawtypes" })
  /**
   * 查选的业务逻辑
   * @return
   */
public List getAllTeachers(){
      String hql="from Teacher";
      lists=query.query(hql);
      return
lists;
   }
  /**
   * 添加的业务逻辑
   * @param s
   * @return
   */
  public
boolean addTeacher(Teacher t1) {
      return
Add.add(t1);
  }
}
3.11 测试类TestDemo.java

package cn.com.bochy.test;
importcn.com.bochy.biz.StuBiz;
importcn.com.bochy.biz.TeacherBiz;
importcn.com.bochy.entity.Stu;
importcn.com.bochy.entity.Teacher;
public
class TestDemo {
  public
static void main(String[]
args) {
     StuBiz biz=new StuBiz();
     Stu s1=new Stu();
      s1.setId(5);
      s1.setAge(25);
      s1.setName("dsew25");
      biz.add(s1); 
      System.out.println(biz.getAllStus().size());
      for(Object
s:biz.getAllStus()) {
         if(sinstanceof Stu) {
             Stu stu=(Stu)s;
             System.out.println(stu.getId()+" "+stu.getName()+" 
"+stu.getAge());
         }
      }
     
     TeacherBiz tbiz=new TeacherBiz();
      Teacher t1=new Teacher();
    t1.setId(5);
    t1.setName("sds5");
    t1.setAge(25);
   
    tbiz.addTeacher(t1);
      System.out.println(tbiz.getAllTeachers().size());
      for(Object
s:tbiz.getAllTeachers()){
         if(sinstanceof Teacher) {
             Teacher t=(Teacher)s;
             System.out.println(t.getId()+" "+t.getName()+"  "+t.getAge());
         }
      }
}
}

四、推荐内容

http://blog.csdn.net/zhoudaxia/article/details/33731583