对象开发的好处和坏处

           对于现在这个项目对象开发的好处暂时大于坏处

service代码：

java 代码

public class ClientGroupClientService {
    private Connection con;
    private ClientGroupClientDAO cgcdao;
    private final static int INSERT = 1;
    private final static int UPDATE = 2;
    private final static int DELETE = 3;

    public ClientGroupClientService() {
//      con = ConnUtils.getConnection() ;
        con = ConnUtils.getDefaultConnection();
        cgcdao = new ClientGroupClientDAO(getPdao());
    }

    /**
     * 初始化该pojo的基本信息
     * @return Pojo的基本信息,用于dao中的构造参数
     */
    private PojoDao getPdao(){
        PojoDao pdao = new PojoDao();
        pdao.setView_name("V_CLIENTGROUPCLIENT");//设置此操作类的视图
        pdao.setPrimarykeyname("objectID");//设置此视图的主键
        pdao.setP_insert("{call pkg_hedge.up_AddClientGroupClient(?,?,?)}");
        pdao.setP_update("{call pkg_hedge.up_ModClientGroupClient(?,?,?)}");
        pdao.setP_delete("{call pkg_hedge.up_DelClientGroupClient(?,?,?)}");
        return pdao;
    }

    /*
     * 分页下载数据
     * */
    public void getClientGroupCLientByPage(Page page) {
        int pageSize = page.getPageSize();
        int pageIndex = page.getPageIndex();
        int lastNum = pageIndex*pageSize;
        int beginNum = (pageIndex-1)*pageSize;
        ResultSet rs = cgcdao.getDataByPage(con, lastNum, beginNum);
        ClientGroupClient temp = null;

        List templist = null;
        if(rs!=null)
        try {
            templist = new ArrayList();
            while(rs.next()){
                temp = new ClientGroupClient();
                temp.setObjectID(new Long(rs.getLong("objectid")));
                temp.setClientID(rs.getString("clientid"));
                temp.setCreater(rs.getString("creater"));
                temp.setGroupID(new Long(rs.getLong("groupid")));
                templist.add(temp);
            }
        page.setList(templist);    //添加当页数据
        rs = cgcdao.getCountNum(con);
        if(rs!=null)
        if(rs.next()){
            page.setRecordCount(rs.getInt(1));
            page.setPageCount((page.getRecordCount()+(page.getPageSize()-1))/page.getPageSize());//设置分页的页数
        }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            temp = null;
            ConnUtils.close(rs, null, con);
        }
    }

    public String insert(List list){
        return cgcdao.operate(con, list, INSERT);
    }

    public String update(List list){
        return cgcdao.operate(con, list, UPDATE);
    }

    public String delete(List list){
        return cgcdao.operate(con, list, DELETE);
    }

    public String batchCRUD(List inserts,List updates,List deletes){
        String re_msg=null;
        if(inserts!=null && inserts.size()>0)
            re_msg = cgcdao.operate(con, inserts, INSERT);
        if(updates!=null && updates.size()>0)
            re_msg = cgcdao.operate(con, updates, UPDATE);
        if(deletes!=null && deletes.size()>0)
            re_msg = cgcdao.operate(con, deletes, DELETE);
        closeCon();
        return re_msg;
    }

    private void closeCon(){
        ConnUtils.close(con);
    }

}

在批量的方法中调用dao层的抽象方法，好处是将同一过程的代码全部都抽象化，这样操作的前提是对象化的开发，一切参数都是对象化，包括传入数据库中存储过程的参数也是对象化的，这样开发的好处有两点：

第一：维护方便，需要修改的只有存储过程中的对象，和表现层的现实对象，中间过程不会变动特别是抽象的dao层不会变。

第二：简化开发代码，特别是简化了dao曾的代码，其他层的代码也大相径庭，特别是给予dorado的开发模式更是如此。

事例代码如下：

java 代码

public abstract class AcceccDao {
    protected ResultSet rs;
    protected CallableStatement proc;
    protected PreparedStatement pst;
    protected Person person;
    protected Iterator it;
    private Object temp; //临时的变量

    protected PojoDao pdao;
    public AcceccDao() {
        // TODO Auto-generated constructor stub
    }
    /**
     * 通过继承类的构造函数初始化将要操作的视图和存储过程名
     * 视图名称为v_xxx
     * 其中primarykey 用于排序,如果可以传入一个null
     * 存储过程为"{call pkg_hedge.uf_AddCreditrecord(?,?,?)}"包含了所有的call和大括号
     * @param view_name
     * @param p_insert
     * @param p_update
     * @param p_delete
     */
    public AcceccDao(PojoDao pdao){
        this.pdao = pdao;
    }

    /**
     * 返回分页数据集
     * @param con 连接对象
     * @param lastNum 分页数据的最后一条数据号
     * @param beginNum .......第一条数据号
     * @return
     */
    public ResultSet getDataByPage(Connection con, int lastNum,int beginNum ) {
        StringBuffer sb = new StringBuffer();
        try {
            sb.append("select * from (select vin.*,rownum rn from "+pdao.getView_name()+" vin where rownum <= ?) vout where rn > ?");
            if(pdao.getPrimarykeyname()!=null)
                 sb.append(" order by vout."+pdao.getPrimarykeyname()+" asc");
            pst = con.prepareStatement(sb.toString());
            pst.setInt(1, lastNum);
            pst.setInt(2, beginNum);
            return pst.executeQuery();
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }finally{

        }
    }

    /**
     * 返回该视图记录数的总条数
     */
    public ResultSet getCountNum(Connection con){
        String sql = "select max(rownum) from "+pdao.getView_name();
        try {
            pst = con.prepareStatement(sql);
            return pst.executeQuery();
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 此方法用于批量或者单个处理增删该
     * @param con  连接对象
     * @param list 操作的对象pojo
     * @param operateType 在service里面定义成常量
     * private static final int INSERT=1;
     * private static final int UPDATE=1;
     * private static final int DELETE=1;
     * @return
     */
    public String operate(Connection con, List list,int operateType) {
        try {
            String sql = null;
            switch (operateType) {
            case 1:
                sql = pdao.getP_insert();
                break;
            case 2:
                sql = pdao.getP_update();
                break;
            case 3:
                sql = pdao.getP_delete();
                break;
            }
            proc = con.prepareCall(sql);
            for(it = list.iterator();it.hasNext();){
                temp = (ClientGroupClient)it.next();
                proc.registerOutParameter(1, OracleTypes.INTEGER);
                proc.registerOutParameter(2, OracleTypes.VARCHAR);
                proc.setObject(3, temp);
                proc.execute();
            }
            return proc.getString(2);
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        } finally{
            temp = null;
            ConnUtils.close(null, proc, null);
        }
    }
}

 

而实现类中dao的代码为：

java 代码

public class ClientGroupClientDAO extends AcceccDao {
    public ClientGroupClientDAO(PojoDao pdao){
        super(pdao);
    }
}

其中构造函数的参数为改到要操作的数据库中的信息，比如视图名，主键名，插入存储过程名，更新存储过程名，以及其他任何你需要的在dao的抽象层中需要的参数，都可以定义在这里。

java 代码

public class PojoDao {
    private String view_name; //视图的名称
    private String primarykeyname;//此表的主键 用于排序
    private String p_insert; //插入的存储过程名
    private String p_update; //更新的存储过程名
    private String p_delete; //删除的...
//  private String order;    //用于asc 或者 desc   这个主要是为了说明面向对象的设计思想

    public PojoDao() {
    }

    public String getP_delete() {
        return p_delete;
    }
    public void setP_delete(String p_delete) {
        this.p_delete = p_delete;
    }
    public String getP_insert() {
        return p_insert;
    }
    public void setP_insert(String p_insert) {
        this.p_insert = p_insert;
    }
    public String getP_update() {
        return p_update;
    }
    public void setP_update(String p_update) {
        this.p_update = p_update;
    }
    public String getPrimarykeyname() {
        return primarykeyname;
    }
    public void setPrimarykeyname(String primarykeyname) {
        this.primarykeyname = primarykeyname;
    }
    public String getView_name() {
        return view_name;
    }
    public void setView_name(String view_name) {
        this.view_name = view_name;
    }
}

在service中将这个PojoDao构造好就可以啦：

 

java 代码

public ClientGroupClientService() {
    con = ConnUtils.getDefaultConnection();
    cgcdao = new ClientGroupClientDAO(getPdao());//调用getPdao();
}

/**
 * 初始化该pojo的基本信息
 * @return Pojo的基本信息,用于dao中的构造参数
 */
private PojoDao getPdao(){
    PojoDao pdao = new PojoDao();
    pdao.setView_name("V_CLIENTGROUPCLIENT");//设置此操作类的视图
    pdao.setPrimarykeyname("objectID");//设置此视图的主键
    pdao.setP_insert("{call pkg_hedge.up_AddClientGroupClient(?,?,?)}");
    pdao.setP_update("{call pkg_hedge.up_ModClientGroupClient(?,?,?)}");
    pdao.setP_delete("{call pkg_hedge.up_DelClientGroupClient(?,?,?)}");
    return pdao;
}

数据库中也是基于type的变成模式.

好处还是很多的。

 

但是也有不利的地方：

例如我们本次采用的是oracle数据库，存储使用起来太麻烦了，pojo中要匹配oracle的字段类型，多做好多工作，并且在tomcat下能够运行，换成weblogic就跑不动了。

分享到：

oracle arr | dorado－上海期货

• 2007-07-28 21:49
• 浏览 1414
• 评论(0)
• 查看更多

相关推荐

2024前端开发必会面试题和多种实战技巧

以上是对前端开发领域中一些重要的知识点和实战技巧的详细介绍。对于前端开发者来说，掌握这些基础知识和技术不仅可以帮助他们更好地准备面试，还能提升日常开发的工作效率。希望本文对您有所帮助！

C#中静态与非静态方法比较

### C#中静态与非静态方法的深入解析 #### 引言 在C#编程语言中，静态方法和非静态方法是两种常见...通过深入了解这两种方法的特点，开发者可以在实际开发过程中更加灵活高效地利用它们，从而提高代码的质量和性能。

60条Android开发注意事项与经验总结

4. 单一职责原则：不要相信庞大的管理类的东西会带来什么好处，可能是一场灾难，而要时刻注意单一职责原则，一个类专心做好一件事情更为清晰。 5. 延迟初始化：如果数据没有必要加载，数据请务必延迟初始化，谨记为...

多态详解= 多态的优缺点在不同的编程场景中不同的适用性

2. **对象间的转型问题**：多态涉及到向上转型和向下转型，向下转型（父类对象实例化子类对象）属于强制转换，如果不当使用可能会导致类型转换异常（ClassCastException）。 3. **性能开销**：虽然多态提高了代码...

2018年JAVA架构师面试后的问题汇总-word范文 (2页).pdf

好处是可以控制实例化过程，坏处是打破了单例模式的常规实现。 9. **排序算法**：常见的排序算法有冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序等，它们的时间复杂度各不相同，从O(n^2)到O(n log n)...

ABAP面试大全

索引有好处也有坏处，如加速查询但占用额外空间。 - 透明表的数据类影响存储效率，透明表分为普通表、Cluster表和结构化表。 - 找数据库表可以使用SE16（数据库浏览器）、DD03L（表维护事务代码）等工具。 - 锁...

百度面试题汇总（java）

7. **闭包的好处与坏处**：闭包可以保持私有变量，但也可能导致内存泄漏。 8. **this指针的使用**：`this`在不同上下文中指向不同的对象，如函数调用、对象方法调用等。 9. **函数绑定**：使用`.bind()`方法可以...

C# WINFORM 控件双向绑定少为人知的秘密

如果控件的值是对象或 decimal、int 等非字符串类型，那么这个属性非常重要。如果将其设置为 false，可能会导致控件的值丢失。 此外，我们还可以使用 DataView 来实现双向绑定。当我们使用 DataSet 或 DataTable ...

mybatis-第三天.doc.pdf

- MyBatis 优势：封装了 JDBC，降低了开发工作量，解耦了业务代码和 SQL 代码，通过 XML 或注解方式配置 SQL，更易于维护。 3. **MyBatis 快速入门** - 创建 Maven 工程，引入 MyBatis 相关依赖，例如 MyBatis ...

JavaScript高阶第三天.xmind

js高阶笔记总结： 严格模式： 1.开启严格模式："use strict" 2.... 3.... 高阶函数： 满足其中之一即高阶函数： 1.... 2.... 1.... 2.闭包的好处： 1.... 2.... 3.闭包的坏处： 1.... 1.... 2.递归函数的作用和循环效果... ①将对象转为字

数据库基础运用

识别和预防内存泄漏是软件开发中的重要任务。 #### 十、SQL Server中的高级数据管理技巧 在SQL Server中，理解并有效利用ID和LastUpdateDate字段，能够帮助优化数据更新和查询逻辑，进一步提升数据库应用的性能和...

JS重载实现方法分析

对于进一步学习JavaScript，可以参考的其他内容包括面向对象编程入门、JSON操作、特效与动画制作、查找和调试技巧、数据结构与算法、遍历算法、数学运算等，这些内容都是提高JavaScript编程能力的关键点。

php 面试碰到过的问题 在此做下记录

- 使用过哪些PHP框架，如Laravel, Symfony, CodeIgniter等，了解这些框架的基本原理和特性，以及如何利用它们提高开发效率。 7. **PHP与MySQL交互**： - 应熟悉如何使用`PDO`或`mysqli`进行数据库连接，了解...

Global site tag (gtag.js) - Google Analytics