DAO---反射

1.DAO--访问数据信息的类,对数据进行增删改查的操作,不包含任何的相关信息

其他如何使用DAO,定义DAOImplement类直接继承DAO父类 在DAO中进行如下的操作

1)void update(String sql,Object args);----Insert,Select,DELETE

 1 public void update(String sql,Object... args)
 2     {
 3         Connection conn=null;
 4         PreparedStatement ps=null;
 5         try {
 6             conn=JDBCUtils.getMysqlConn();
 7             ps=conn.prepareStatement(sql);
 8
 9             // args 填补占位符
10             for(int i=0;i<args.length;i++)
11             {
12                 ps.setObject(i+1, args[i]);
13             }
14             ps.executeUpdate();
15         } catch (Exception e) {
16             // TODO Auto-generated catch block
17             e.printStackTrace();
18         }finally{
19             JDBCUtils.closeMysql(ps, conn);
20         }
21     }

2)<T> T get(Class<T>clazz,String sql,Object args);----查询一条记录返回对应的对象

    返回查询对象的实例: 当我们使用 ResultSet rs=ps.executeQuery(); 得到一个属于ResultSet集合从中得到ResultSetMeta,事实上我们不知道从SQL查询所能够得到一些什么样的东西只能通过反射动态的建立一个对象,将对象封装到JavaBean中,再从JavaBean取得查询的结果

 1      Connection conn=null;
 2         PreparedStatement ps=null;
 3         ResultSet rs=null;
 4         T object=null;
 5         try {
 6             conn=JDBCUtils.getMysqlConn();
 7             ps=conn.prepareStatement(sql);
 8
 9             // args 填补占位符
10             for(int i=0;i<args.length;i++)
11             {
12                 ps.setObject(i+1, args[i]);
13             }
14             // rs 包含的查询填充占位符对应的值
15             rs=ps.executeQuery();
16             while(rs.next())
17             {
18                 // 得到SQL数据库列的别名,与类的属性名进行反射重建对象
19                ResultSetMetaData rsmd=rs.getMetaData();
20
21                // Map 将别名与值建立映射的关系
22                Map<String,Object> map=new HashMap<>();
23                for(int i=0;i<rsmd.getColumnCount();i++)
24                {
25                    String Label=rsmd.getColumnLabel(i+1);
26                    Object value=rs.getObject(i+1);
27                    map.put(Label, value);
28                }
29
30                if(map.size()>0)
31                {
32                    //调用反射每一条记录生成新的的对象
33                     object=clazz.newInstance();
34
35                    for(Map.Entry<String, Object>entiry:map.entrySet())
36                    {
37                        String prop=entiry.getKey();
38                        Object value=entiry.getValue();
39
40                        // 直接进行反射
41                        ReflectionUtils.setFieldValue(object, prop, value);
42                    }
43                }
44
45             }
46
47         } catch (Exception e) {
48             // TODO Auto-generated catch block
49             e.printStackTrace();
50         }finally{
51             JDBCUtils.closeMysql(ps, conn);
52         }
53         return object;
54     }

对于此Test的案例:sql 中 flow_id flowId 只是为了将sql中别名另起一个别名 为了与类的属性名称对应。

3) <T> List<T> getForList(Class<T> clazz,String sql,Object args)----查询多条信息返回对象的集合

 1     public <T> List<T> getForList(Class<T> clazz,String sql,Object ...args)
 2     {
 3         Connection conn=null;
 4         PreparedStatement ps=null;
 5         ResultSet rs=null;
 6         List<T> list=new ArrayList<>();
 7         try {
 8             conn=JDBCUtils.getMysqlConn();
 9             ps=conn.prepareStatement(sql);
10
11             // args 填补占位符
12             for(int i=0;i<args.length;i++)
13             {
14                 ps.setObject(i+1, args[i]);
15             }
16             // rs 包含的查询填充占位符对应的值
17             rs=ps.executeQuery();
18             List< Map<String,Object>> Listmap=new ArrayList();
19             while(rs.next())
20             {
21                 // 得到SQL数据库列的别名,与类的属性名进行反射重建对象
22                ResultSetMetaData rsmd=rs.getMetaData();
23
24                // Map 将别名与值建立映射的关系
25               Map<String,Object>map=new HashMap<>();
26                for(int i=0;i<rsmd.getColumnCount();i++)
27                {
28                    String Label=rsmd.getColumnLabel(i+1);
29                    Object value=rs.getObject(i+1);
30                    map.put(Label, value);
31                }
32                Listmap.add(map);
33
34             }
35             T bean=null;
36              if(Listmap.size()>0)
37              {
38
39                 for(Map<String,Object> m:Listmap)
40                 {
41                       for(Map.Entry<String, Object>entiry:m.entrySet())
42                        {
43                            String prop=entiry.getKey();
44                            Object value=entiry.getValue();
45
46                            bean=clazz.newInstance();
47                            // java.beanUtils
48                            BeanUtils.setProperty(bean, prop, value);
49                        }
50                       list.add(bean);
51                 }
52              }
53
54
55
56         } catch (Exception e) {
57             // TODO Auto-generated catch block
58             e.printStackTrace();
59         }finally{
60             JDBCUtils.closeMysql(ps, conn);
61         }
62         return list;
63     }

4)<E> E getForValue(Class<T>clazz,String sql,Object args);----查询某条记录的某个字段

时间: 2024-11-05 14:59:22

DAO---反射的相关文章

Dao泛型设计和反射反型

(1)DAO泛型设计:当二哥或多个类中有类似的方法时,可以将这些累死的方法提出到类中,形式一个泛型父类 (2)反射反型:在泛型父类中获取子类的具体类型的过程,叫反射反型 1 package cn.itcast.web.generic; 2 3 import java.lang.reflect.ParameterizedType; 4 import java.lang.reflect.Type; 5 import org.apache.commons.dbutils.QueryRunner; 6

java反射+java泛型,封装BaseDaoUtil类。供应多个不同Dao使用

当项目是ssh框架时,每一个Action会对应一个Service和一个Dao.但是所有的Ation对应的Dao中的方法是相同的,只是要查的表不一样.由于封装的思想,为了提高代码的重用性.可以使用java中的泛型+反射去实现最终的封装,将所有的Dao层的共同部分写一个BaseDaoUtil.而所有的Dao都继承这个类. 思路: ----->(1)反射+泛型 ----->(2)当生成子类对象(UserDao),调用空构造时(new UserDao()),子类的空构造会默认调用父类的空构造器(new

利用反射搭建项目的dao层,从此可以告别被人的dao层框架了(spring+反射)

作为一名刚入手的小白程序猿,不但"TA"不懂我们,就连自己都不懂自己,苦逼的程序猿,只能每天都是在给自己充电了.让"TA"和自己更了解.今天笔者又来吹吹水了,各位客官请买好零食咯,好了废话不多说了. 在以前做项目的时候,一般想到搭项目都是用别人的框架来做,但是别人的框架都是别人封装好的很多东西,对不太熟源码的码农来说就是苦逼呀,所以像笔者这种小白又不甘心,所以笔者就用反射来自己封装一个操作dao层的框架(不算一个框架,就是这么称呼吧),说起反射可能是很多像笔者这样的

反射泛型,Dao设计模型 (编码时需要用到)

Dao package com.xiaofan.reflect; import java.io.Serializable; public interface Dao<T> { /** * 添加实体(Entity--Domain)数据到数据库中 * @param t */ void save(T t); /** * 修改数据库中的实体 * @param t */ void update(T t); /** * 根据主键删除记录 * @param pk */ void delete(Seriali

Hibernate Dao映射配置通用接口类反射获取加载calass实例

接口: package com.ph.dao; import java.io.Serializable; import java.util.List; import org.hibernate.criterion.DetachedCriteria; public interface BaseDao<T> { public void save(T t); public void delete(T t); public void update(T t); public T findById(Ser

java注解和反射制作dao基类的练习

首先是三个注解 主键注解 package comments; 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.lan

利用反射实现类通用的DAO层

public void add(Object object) throws SQLException { ResultSet rs=null; PreparedStatement ps=null; Connection con=null; //获取表名 Class c= object.getClass(); String className=c.getName(); String declareName=className.substring(className.lastIndexOf(".&q

小例子 使用反射机制创建dao的factory

public class Factory { private static Properties props =   new Properties(); static{  InputStream ips =    Factory.class.getClassLoader()   .getResourceAsStream(     "util/dao.properties");  try {   props.load(ips);  } catch (IOException e) {   

Spring 通过定时器 通过反射 Resource Dao层为空

通过定时器,调用方法,方法中需要用到Dao层实体,Resource时为空 跟换Dao的注入方式: 从 Resource 改为 GlobalFunction.getBeanByName()即可, 原文地址:https://www.cnblogs.com/du1991/p/8882461.html

反射实现数据库增删改查DAO及DAOImpl源代码(二)

配置文件源码 配置文件主要用于配置数据库对象(javaBean),配置表名,配置查询条件,配置删除条件 文件名称:objectConfigPath.properties 这个配置文件里面配置的是另外一个配置文件的文件路径 objectConfigPath=com/javasm/supermarket/dao/config/order/objectConfig.properties 文件名称:objectConfig.properties 这个配置文件是本项目很多实现的关键,配置文件中有备注,说的