A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© Jeik 中级黑马   /  2014-11-6 17:59  /  1489 人查看  /  1 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

DAO结构编程理解:
我们不妨想想jdbc结构,jdbc作为sun公司定义的一套接口规范,旗下很多公司都实现 了jdbc接口,即jdbc的实现类 ==数据库。我们知道数据库很多种。由于是这种定义接口规范的方式,可以让编程人员操作jdbc的时候方便的实现数据库的切换。
DAO结构层次如下:
1.dao接口。这里定义了要实现的功能
2.daoImp 接口的实现类
3.daoBeanFactory 用来动态获取daoImp
4.daoConfig.properties 配置文件     
案例代码:完成一个用户的crud编程
  1. import java.util.List;

  2. import cn.jdbc.entity.DaoUser;

  3. public interface UserDao {
  4.         public abstract void add(DaoUser user);
  5.         public abstract void deleteById(int id);
  6.         public abstract void update(String sql);
  7.         public abstract DaoUser findById(int id);
  8.         public abstract List<DaoUser> findAll();
  9. }


  10. package cn.jdbc.daoImp;

  11. import java.sql.Connection;
  12. import java.sql.Date;
  13. import java.sql.PreparedStatement;
  14. import java.sql.ResultSet;
  15. import java.sql.SQLException;
  16. import java.sql.Statement;
  17. import java.text.DateFormat;
  18. import java.text.ParseException;
  19. import java.text.SimpleDateFormat;
  20. import java.util.List;

  21. import cn.jdbc.dao.UserDao;
  22. import cn.jdbc.entity.DaoUser;
  23. import cn.utils.JdbcUtil;

  24. public class UserDaoImp implements UserDao {
  25.         //测试用的 规范是要建立测试类的
  26.         public static void main(String[] args) throws ParseException{
  27.                 /**复习知识点date的用法
  28.                  * 1.Date和String类型的转换
  29.                  *   a.构建simpleDateFormat对象sdf(即格式)
  30.                  *   b.通过sdf.parse(String) 来将一个字符串转换成date对象
  31.                  *   c.通过sdf.format(Date)将Date转成一个字符串
  32.                  * 2.java.util.Date和java.sql.Date的转换
  33.                  *   a.sql.Date date=new sql.Date(new util.Date().getTime() )
  34.                  * 结合1,2就可以将一个字符串按某种要求的格式,通过Util.Date插入到数据库中的sql.Date字段*/
  35.                 UserDaoImp udi=new UserDaoImp();
  36.                 /*DateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
  37.                 //sdf.parse("1988-02-23") 这是java.util.Date 类型在。getTime() 变成long
  38.                 Date s=new Date(sdf.parse("1990-12-06").getTime());
  39.                 DaoUser user=new DaoUser(2,"zhansan",s);
  40.                 udi.add(user);*/
  41.                 //udi.deleteById(1);
  42.                 //DaoUser user=udi.findById(2);
  43.                 //System.out.println(user.getName());
  44.                
  45.                 udi.update("update daoUser set birthday=to_date('1991-06-18','yyyy-MM-dd')" +
  46.                                 " where id=1");
  47.                
  48.         }
  49.         @Override
  50.         public void add(DaoUser user) {
  51.                 Connection conn=JdbcUtil.getConnection();
  52.                 PreparedStatement ps=null;
  53.                 String sql="insert into daoUser values(?,?,?)";
  54.                 try {
  55.                         ps=conn.prepareStatement(sql);
  56.                         ps.setInt(1, user.getId());
  57.                         ps.setString(2,user.getName());
  58.                         ps.setDate(3,user.getDate());
  59.                         ps.executeUpdate();
  60.                 } catch (SQLException e) {
  61.                         e.printStackTrace();
  62.                         throw new RuntimeException(e);
  63.                 }finally{
  64.                         JdbcUtil.freeSource(null, ps, conn);
  65.                 }
  66.         }

  67.         @Override
  68.         public void deleteById(int id) {
  69.                 Connection conn=JdbcUtil.getConnection();
  70.                 Statement st=null;
  71.                 String sql="delete daoUser where id="+id;
  72.                 try {
  73.                         st=conn.createStatement();
  74.                         st.execute(sql);
  75.                 } catch (SQLException e) {
  76.                         e.printStackTrace();
  77.                         throw new RuntimeException(e);
  78.                 }finally{
  79.                         JdbcUtil.freeSource(null, st, conn);
  80.                 }
  81.                
  82.         }

  83.         @Override
  84.         public List<DaoUser> findAll() {
  85.                 return null;
  86.         }

  87.         @Override
  88.         public DaoUser findById(int id) {
  89.                 Connection conn=JdbcUtil.getConnection();
  90.                 Statement st=null;
  91.                 ResultSet rs=null;
  92.                 String sql="select * from daoUser where id="+id;
  93.                 try {
  94.                         st=conn.createStatement();
  95.                         rs=st.executeQuery(sql);
  96.                         if(rs.next()){
  97.                                 DaoUser user=new DaoUser();
  98.                                 user.setId(rs.getInt("id"));
  99.                                 user.setName(rs.getString("name"));
  100.                                 user.setDate(rs.getDate("birthday"));
  101.                                 return user;
  102.                         }
  103.                 } catch (SQLException e) {
  104.                         e.printStackTrace();
  105.                         throw new RuntimeException(e);
  106.                 }finally{
  107.                         JdbcUtil.freeSource(null, st, conn);
  108.                 }
  109.                
  110.                 return null;
  111.         }

  112.         @Override
  113.         public void update(String sql) {
  114.                 Connection conn=JdbcUtil.getConnection();
  115.                 Statement st=null;
  116.                 try {
  117.                         st=conn.createStatement();
  118.                         st.executeUpdate(sql);
  119.                 } catch (SQLException e) {
  120.                         throw new RuntimeException(e);
  121.                 }finally{
  122.                         JdbcUtil.freeSource(null, st, conn);
  123.                 }
  124.         }

  125. }


  126. package cn.jdbc.daoBeanFactory;

  127. import java.io.IOException;
  128. import java.io.InputStream;
  129. import java.util.Properties;

  130. import cn.jdbc.dao.UserDao;

  131. public class UserDaoBeanFactory {

  132.         //从配置文件中动态的选择dao的实现类。实现类dao和某个imp绑定
  133.         public static UserDao getInstance(){
  134.                 InputStream ins=UserDaoBeanFactory.class.getClassLoader().
  135.                        getResourceAsStream("daoConfig.properties");
  136.                 Properties prop=new Properties();
  137.                 UserDao userDao=null;
  138.                 try {
  139.                         prop.load(ins);
  140.                         userDao=(UserDao) Class.forName(prop.getProperty("daoImp")).newInstance();
  141.                 } catch (Exception e) {
  142.                         throw new RuntimeException(e);
  143.                 }
  144.                 return userDao;
  145.         }
  146. }


  147. package cn.jdbc;

  148. import java.sql.Date;
  149. import java.text.DateFormat;
  150. import java.text.ParseException;
  151. import java.text.SimpleDateFormat;

  152. import cn.jdbc.dao.UserDao;
  153. import cn.jdbc.daoBeanFactory.UserDaoBeanFactory;
  154. import cn.jdbc.entity.DaoUser;

  155. public class DaoTest {

  156.         /**
  157.          * @param args
  158.          * @throws ParseException
  159.          */
  160.         public static void main(String[] args) throws ParseException {
  161.                 //这里通过factory实现了接口和实现类的解耦,
  162.                 //当我们由于需求需要变更dao的实现类时候,只需在配置文件修改即可
  163.                 UserDao userDao=UserDaoBeanFactory.getInstance();
  164.                 DateFormat df=new SimpleDateFormat("yyyy-MM-dd");
  165.                 Date date=new Date(df.parse("1993-06-18").getTime());
  166.                 userDao.add(new DaoUser(3,"zhaoliu",date));
  167.         }

  168. }
复制代码

1 个回复

倒序浏览
路过               
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马