DAO模式的优势在哪？

这是DAO模式的代码：

package cn.jbit.vo;

/**
 *  宠物类
 */
public class Pet {
	private int id;//宠物id
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}

	private int masterId;//主人id
	public int getMasterId() {
		return masterId;
	}
	public void setMasterId(int masterId) {
		this.masterId = masterId;
	}

	private String name;//昵称
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	private int typeId;//类型id
	public int getTypeId() {
		return typeId;
	}
	public void setTypeId(int typeId) {
		this.typeId = typeId;
	}

	private int health;//健康值
	public int getHealth() {
		return health;
	}
	public void setHealth(int health) {
		this.health = health;
	}

	private int love ;//亲密度
	public int getLove() {
		return love;
	}
	public void setLove(int love) {
		this.love = love;
	}

	private String adoptTime;//领养时间
	public String getAdoptTime() {
		return adoptTime;
	}
	public void setAdoptTime(String adoptTime) {
		this.adoptTime = adoptTime;
	}

	private int status;//状态
	public int getStatus() {
		return status;
	}
	public void setStatus(int status) {
		this.status = status;
	}
}

package cn.jbit.dao;

import java.util.List;

import cn.jbit.vo.Pet;

/**
 * 接口
 */
public interface IPetDAO {
	public boolean doCreate(Pet pet)throws Exception;
	public List<Pet>findInfo(int keyword)throws Exception;
}

package cn.jbit.dbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

import org.apache.log4j.Logger;

/**
 *  数据库连接
 */
public class DataBaseConnection {
	//记录日志
	private Logger logger = Logger.getLogger(DataBaseConnection.class);
	private static final String driverClassName = "oracle.jdbc.driver.OracleDriver";  //驱动字符串
	private static final String url = "jdbc:oracle:thin:@127.0.0.1:1521:oracle10";  //连接字符串
	private static final String user = "admin";
	private static final String password = "admin";
	private Connection conn = null;

	public DataBaseConnection()throws Exception{
		Class.forName(driverClassName);
		this.conn = DriverManager.getConnection(url,user,password);
		logger.debug("连接成功");
	}

	public Connection getConnection(){
		return this.conn;
	}

	/**
	 * 关闭连接
	 */
	public void close(){
		if(null!=conn){
			try {
				conn.close();
			} catch (SQLException e) {
				System.out.println(e);
			}
		}
	}
}

package cn.jbit.factory;
import cn.jbit.Proxy.PetDaoProxy;
import cn.jbit.dao.IPetDAO;

public class factory {
	public static IPetDAO getIpetDAOinstance()throws
	Exception{
		return new PetDaoProxy();
	}
}

package cn.jbit.impl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import cn.jbit.dao.IPetDAO;
import cn.jbit.vo.Pet;

public class PetDaoImpl implements IPetDAO {
	Connection conn = null;
	PreparedStatement patmt = null;
	ResultSet rs = null;

	public PetDaoImpl(Connection conn){
		this.conn = conn;
	}

	public boolean doCreate(Pet pet) throws Exception {
		boolean flag = false;
		String sql = "insert into pet values(pet_sep.nextval,?,?,?,?,?,sysdate,?)";
		this.patmt = this.conn.prepareStatement(sql);
		this.patmt.setInt(1, pet.getMasterId());
		this.patmt.setString(2, pet.getName());
		this.patmt.setInt(3,pet.getTypeId());
		this.patmt.setInt(4, pet.getHealth());
		this.patmt.setInt(5, pet.getLove());
		this.patmt.setInt(6, pet.getStatus());
		if(this.patmt.executeUpdate()>0){			
			System.out.println("插入成功");
			flag = true;
		} 
		return flag;
	}

	public List<Pet> findInfo(int keyword) throws Exception {
		List<Pet> list = new ArrayList<Pet>();
		String sql = "select id,master_id,name,health,love from pet where id = ?";
		this.patmt = this.conn.prepareStatement(sql);
		this.patmt.setInt(1, keyword);
		rs = this.patmt.executeQuery();
		Pet pet = new Pet();
		while(rs.next()){
			pet = new Pet();
			pet.setId(rs.getInt(1));
			pet.setMasterId(rs.getInt(2));
			pet.setName(rs.getString(3));
			pet.setHealth(rs.getInt(4));
			pet.setLove(rs.getInt(5));
		}
		list.add(pet);
		System.out.println("***狗狗***");
		System.out.println("编号\t主人编号\t名字\t健康值\t亲密度");
	   	 System.out.print(pet.getId()+"\t");
	   	 System.out.print(pet.getMasterId()+"\t");
	   	 System.out.print(pet.getName()+"\t");
	   	 System.out.print(pet.getHealth()+"\t");
	   	 System.out.print(pet.getLove()+"\n");
		this.patmt.close();
		return list;
	}

}

package cn.jbit.Test;

import cn.jbit.factory.factory;
import cn.jbit.vo.Pet;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		 Pet pet=new Pet();
	       pet.setMasterId(1);
	       pet.setName("СС");
	       pet.setTypeId(1);
	       pet.setHealth(85);
	       pet.setLove(100);
	       pet.setStatus(1);
	       try {
			   factory.getIpetDAOinstance().doCreate(pet);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

普通的代码：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.*;

/**
 * 测试类
 *
 */
public class Test {
	public static void main(String[] args) {	
		Scanner input = new Scanner(System.in);
		System.out.print("请输入你要查询的编号：");
		int no = input.nextInt();
		try {
			serachData(no);
		} catch (Exception e) {
			System.err.println(e);
		}
	}

	/**
	 * 按编号查询狗狗的信息
	 * @param no
	 * @throws Exception
	 */
	public static void serachData(int no) throws Exception{
		Connection connection = Connection();
		PreparedStatement pstms = null;
		ResultSet rs = null;
		String sql = "select id,master_id,name,health,love from pet where id = ?";
		pstms = connection.prepareStatement(sql);
		pstms.setInt(1, no);
		rs = pstms.executeQuery();
		System.out.println("***狗狗***");
		System.out.println("编号\t主人编号\t名字\t健康值\t亲密度");
		while(rs.next()){
			System.out.println(rs.getInt(1)+"\t"+rs.getInt(2)+"\t"+rs.getString(3)+"\t"+rs.getInt(4)+"\t"+rs.getInt(5));
		}
	}

	/**
	 * 连接的方法
	 * @return conn
	 * @throws Exception
	 */
	public static Connection Connection() throws Exception{
		Connection conn = null;
		if(conn == null){
			Class.forName("oracle.jdbc.driver.OracleDriver");
			conn = DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:oracle10","admin","admin");
			System.out.println("连接成功");
		}
		return conn;
	}
}

虽然学了OOP编程思想，但感觉DAO模式和普通代码没什么区别，反而没用模式的代码还简单一点。
有点迷惑...
就算在普通代码里扩展其他功能，不用改其他方法。也可以实现。
说白了，在普通代码中只要有一个方法或一个类的改动能影响到其他方法、类。有实例来证明。 谢谢！

7 个解决方案

#1

那是你的系统还太简单:
如果有N个DAOImpl都统一有IPetDAO接口的功能,你分发给程序员去做,按你规定的接口规格开发.
你觉得得有必要吗?

他们只要implements IPetDAO,系统就会给他们规定好方法格式,而且实现了多态,对系统扩充有很大帮助.

#2

是的，可以实现，但是在大型的项目开发中，不是一个人开发的，那么多人协作的这种开发模式这种做法显然不合适，这主要体香分层的思想，不同的层次处理不同的事情，想DAO层主要处理与数据库的交互，service主要处理业务逻辑，service层调用DAO层提供的接口，不用管他的实现！
在维护的时候这种方式也是很好的，可以很快找到责任出在哪里！~

#3

DAO模式作为与数据库打交道的东西,他只关注怎么将数据写入数据库,和怎么取出来.
作为DAO中的数据类型他不依赖于任何技术,jdbc也好,hibernate也好,他对你底层的访问提供了很好的支持
例如：UserDao(Interface)
这个时候你可以实现一个UserDaoJdbcImp,也可以实现UserDaoHibernateImp,
在这一层,我们不关心具体的业务逻辑,可以进行单独的测试,是一个独立的模块.利于分工.
而在service层次上,我们更加关注业务,我们要保证业务的完整性,和数据的一制性,我们并不关心底层是jdbc还是hibernate,在这里我们需要向UI层提供Bussiness Logic,也许以后你的实现将会更改成为分布的,需要调用EJB,JMS,或者,webservice,那么我们替换掉serviceImp即可.
通过实现DAO,我们达到了解耦合的目的,达到了饮场实现的目的,使的程序更加的健壮,虽然复杂性是增加了.
 
这样说比较抽象，或许你还没明白，特别时（当你的开发中只涉及到一种数据库链接方式hibernate，jdbc或其它的；又或者当你的开发每个service中只涉及一个dao，不牵涉多个表操作，但这种情况比较少）你还是会觉得dao的作用不大。
 
但是，以软件开发思想及面向对象思想考虑，dao还是有必要的——特别是对于比较大型的项目时，分工比较细，为了方便后期维护。当然，没有绝对的技术，开发时应该看需要，看环境灵活应用.

#4

DAO 模式可以提供更好的解糯，将业务逻辑层与持久层访问技术分离，使业务逻辑
层无须关注底层数据库访问的实现。使用DAO 模式主要有如下优势。


• DAO 模式可抽象出数据访问方式，在BO 访问数据源时，完全感觉不到数据源的
存在。软件工程里面有一条很重要的法则，就是一个对象对其他对象的了解越少
越好，了解越少就意味着依赖越少，可复用性越高。

• DAO 将数据访问集中在独立的一层。因为所有的数据访问都由DAO 代理，这层
独立的DAO 就将数据访问的实现与系统的其余部分剥离，将数据访问集中使得
系统更具可维护性。

• DAO 还降低了BO 层的复杂程度。由DAO 管理复杂的数据访问，从而简化了BO 。
所有与数据访问实现有关的代码(如SQL 语言等)都不用写在BO 里，从而使
BO 可以集中精力处理业务逻辑，提高了代码的可读性和生产率。


• DAO 还有助于提升系统的可移植性。独立的DAO 层使得系统能在不同的数据库
之间轻易切换，底层的数据库实现对于BO 来说是不可见的。数据移植时影响的
仅仅是DAO 层，切换不同的数据库并不会影响BO ，因此提高了系统的可复用性。

#5

很小的项目分不分层不很重要，优势体现不明显

#6

很小的系统，分层了 只会增加代码的复杂度；
需求稳定的系统，分层 也只会增加代码的复杂度；

大系统，牛逼的系统，不分层，就等着分人来维护吧；

分层，是一个隔离的概念，没层处理每层的事情，变化有可能只影响到一层，比如业务逻辑变化只在service层；持久层 基本不影响，因为他逻辑很问题就是 c/r/u/d

封装变化点，利于维护;

代码清晰了，维护方便了，就少了骂娘的声音......

#7

？？？？为什么我的回复显示不出来？