[原创]java WEB学习笔记27：深入理解面向接口编程

本博客为原创：综合 尚硅谷（http://www.atguigu.com）的系统教程（深表感谢）和 网络上的现有资源(博客，文档，图书等)，资源的出处我会标明

本博客的目的：①总结自己的学习过程，相当于学习笔记 ②将自己的经验分享给大家，相互学习，互相交流，不可商用

内容难免出现问题，欢迎指正，交流，探讨，可以留言，也可以通过以下方式联系。

本人互联网技术爱好者，互联网技术发烧友

微博：伊直都在0221

QQ：951226918

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

1.面向接口编程的优势

　　1）增加了程序的课扩展性，降低耦合度。即，只需要知道方法就好了，具体的实现不关注。如果需要新的功能，添加在接口中添加方法的声明，还有具体的实现类，这就是可扩展性。

　　2）程序的可配置性。通过一个配置的修改，就可以达到不同的实现的目的。

 

2.面向接口编程的实例。结合上mvc综合实践

　　需求：通过MVC设计模式，实现对用户的增删改查操作。提供两种实现方式：jdbc，xml ; 通过工场模式 和 MVC设计模式 实现对实现方式的切换。

　　代码：①  CustomerDAOFactory: 单例的 CustomerDAO 工场类。采用饿汉式，线程安全。返回一个CustomerDAO 对象的工厂。

　　　　　②  InitServlet: 一个Servlet 类，实现了init() 方法，读取  实现方式 配置文件  switch.properties , 获取 设置的 type。

　　　　　③  CustomerServlet2: 前台请求的Servlet, 其中有一个CutomerDAO 的私有属性。可以由CustomerDAOFactory 创建。

　　　　   ④  CustomerDAOXMLImpl: CustomerDAO 接口的XML 形式的实现类。

　　　　　⑤  CustomerDAOJdbcImpl: CustomerDAO 接口的JDBC实现类。

　　　　　⑥  switch.properties: 实现方式 type 的配置文件。

　　　　   ⑦  customer.xml: customer 的xml 存储文件

　　　　　⑧  web.xml:  web的配置文件。此处只需配置 InitServlet的加载时间。而Servlet 的url-parttern 则由系统通过注解的方式实现配置

　　　　　⑨  CustomerDAO : 操作 customer的 DAO接口

 

接口的关系图：
　　

 

3.具体代码的实现：

 

　　1）CustomerDAOFactory.java

package com.jason.mvcapp.dao.factory;  2 
import java.util.HashMap;  4 import java.util.Map;  5 
import com.jason.mvcapp.dao.CustomerDAO;  7 import com.jason.mvcapp.dao.impl.CustomerDAOJdbcImpl;  8 import com.jason.mvcapp.dao.impl.CustomerDAOXMLImpl;  9 
/*** 11  * 12  * @author: jason 13  * @time:2016年5月28日下午5:37:39 14  * @description:单例的 CustomerDAO 工场类。采用饿汉式，线程安全 15  */
public class CustomerDAOFactory { 17 
    private Map<String , CustomerDAO> daos = new HashMap<String, CustomerDAO>(); 19     
    //1.私有化构造器
    private CustomerDAOFactory(){ 22         
        daos.put("jdbc", new CustomerDAOJdbcImpl()); 24         daos.put("xml", new CustomerDAOXMLImpl()); 25         
 } 27     //2.创建一个静态的实例
    private static CustomerDAOFactory instance = new CustomerDAOFactory(); 29     //3.提供获取实例的方法
    public static CustomerDAOFactory getInstance() { 31         return instance; 32  } 33         
    private static String type = null; 35     
    public  void setType(String type) { 37         this.type = type; 38  } 39     
    public static String getType() { 41         return type; 42  } 43     public CustomerDAO getCustomerDAO(){ 44         
        return daos.get(type); 46  } 47     
}

 

 

　　　　2）InitServlet.java

package com.jason.mvcapp.servlet;  2 
import java.io.IOException;  4 import java.io.InputStream;  5 import java.util.Properties;  6 
import javax.servlet.ServletException;  8 import javax.servlet.annotation.WebServlet;  9 import javax.servlet.http.HttpServlet; 10 
import com.jason.mvcapp.dao.factory.CustomerDAOFactory; 12 
/**
 * Servlet implementation class InitServlet 15  */
@WebServlet("/InitServlet") 17 public class InitServlet extends HttpServlet { 18 
    private static final long serialVersionUID = 1L; 20 
 @Override 22     public void init() throws ServletException { 23         CustomerDAOFactory.getInstance().setType("jdbc"); 24         
        //1.读取类路径下的switch.properties 配置文件
        InputStream is  =  getServletContext().getResourceAsStream("/WEB-INF/classes/switch.properties"); 27     
        Properties properties = new Properties(); 29         try { 30  properties.load(is); 31             
            //2.获取switch.properties 的type 值
            String type = properties.getProperty("type"); 34             
            //3.赋值给CustomerDAOFactory 的type 属性
 CustomerDAOFactory.getInstance().setType(type); 37             
        } catch (IOException e) { 39  e.printStackTrace(); 40  } 41  } 42 
}

 

 

　　3）CustomerServlet2.java

package com.jason.mvcapp.servlet;  2 
import java.io.IOException;  4 import java.lang.reflect.Method;  5 import java.util.List;  6 
import javax.servlet.ServletException;  8 import javax.servlet.annotation.WebServlet;  9 import javax.servlet.http.HttpServlet;  10 import javax.servlet.http.HttpServletRequest;  11 import javax.servlet.http.HttpServletResponse;  12 
import com.jason.mvcapp.dao.CustomerDAO;  14 import com.jason.mvcapp.dao.factory.CustomerDAOFactory;  15 import com.jason.mvcapp.dao.impl.CustomerDAOJdbcImpl;  16 import com.jsaon.mvcapp.domain.CriteriaCustomer;  17 import com.jsaon.mvcapp.domain.Customer;  18 
/**
 * Servlet implementation class CustomerServlet2  21  */
@WebServlet("*.do")  23 public class CustomerServlet2 extends HttpServlet {  24     private static final long serialVersionUID = 1L;  25 
    // 创建一个CustomerDAO对象，多态 27 private CustomerDAO customerDAO = CustomerDAOFactory.getInstance().getCustomerDAO();  28 
    protected void doGet(HttpServletRequest request,  30             HttpServletResponse response) throws ServletException, IOException {  31  doPost(request, response);  32  }  33 
    protected void doPost(HttpServletRequest request,  35             HttpServletResponse response) throws ServletException, IOException {  36         // 1.获取servletPath：/add.do 或者 query.do
        String serveltPath = request.getServletPath();  38 
        // System.out.println(serveltPath);  40         // 2.去除/ 和 .do 得到对应的方法，如 add query
        String methodName = serveltPath.substring(1);  42         methodName = methodName.substring(0, methodName.length() - 3);  43         // System.out.println(methodName);

        try {  46             // 3.利用反射获取methodName对应的方法
            Method method = getClass().getDeclaredMethod(methodName,  48                     HttpServletRequest.class, HttpServletResponse.class);  49 
            // 4.利用反射调用方法
            method.invoke(this, request, response);  52         } catch (Exception e) {  53 
 e.printStackTrace();  55  }  56  }  57 
    private void updateCustomer(HttpServletRequest request, HttpServletResponse response)  59             throws ServletException, IOException {  60         System.out.println("update");  61         request.setCharacterEncoding("UTF-8");  62         
        //1.获取请求信息：id，name，address，phone，oldName  64         
            //1.1 隐藏域的 值
            String  idStr = request.getParameter("id");  67             String  oldNameStr = request.getParameter("oldName");  68             
            //1.2 提交的值
            String  nameStr = request.getParameter("name");  71             String  addressStr = request.getParameter("address");  72             String  phoneStr = request.getParameter("phone");  73         
        //2.验证name 是否可用  75             //通过equalsIgnoreCase() 方式 避免了 大小写的问题。equals 方法区分大小写， 而数据库SQL 不区分大小写
            if(!oldNameStr.equalsIgnoreCase(nameStr)){  77                 //2.1 先比较name 和 oldName 是否相同，若相同，说明name 可用  78                 //2.2 若不相同，则调用CustomerDAO 的getCostomerWithName(String name) 获取 name 在数据库中是否存在
                long rel = customerDAO.getCountWithName(nameStr);  80                 //2.2.1 若存在，则返回值大于 0，则响应 updatecustomer.jsp 页面：通过转发的方式
                if(rel > 0){  82                     // 进行回显字符串，在request 中放入一个属性 message：用户名 name  83                     // 回显：updatecustomer.jsp 的表单值可以回显  84                     // value="<%= request.getParameter("name") == null ? "" : request.getParameter("name") %>" 进行回显  85                     // 注意：name 显示的是 oldName，而address 和 phone 显示的是新的
                    request.setAttribute("message", "用户名 " + nameStr + " 已经被占用了，请重新选择！");  87                     //2.2.2 存在，要求在updatecustomer.jsp 页面显示一条消息：用户名 name 已经被占用了，请重新选择
                    request.getRequestDispatcher("/updatecustomer.jsp").forward(request,response);  89                     // 2.2.3 结束方法：return
                    return;  91  }  92  }  93         
        //3.通过验证后，则将表单封装为一个Customer 对象 customer
            Customer  customer = new Customer(nameStr, addressStr, phoneStr);  96  customer.setId(Integer.parseInt(idStr));  97             
        //4.调用CustomerDAO 的save(Customer customer) 执行更新操作
 customerDAO.update(customer); 100             
        //5.重定向到 query.do 
            response.sendRedirect("query.do"); 103 
 } 105 
    private void editeCustomer(HttpServletRequest request, 107             HttpServletResponse response) throws ServletException, IOException { 108         System.out.println("edit"); 109         String forwardPath = "/error.jsp"; 110         //1. 获取请求参数id
         String idStr = request.getParameter("id"); 112          try { 113              //2. 调用CustomerDAO 的get(id) 方法，获取 和id 对应的Customer 对象
             Customer customer = customerDAO.get(Integer.parseInt(idStr)); 115             if(customer != null){ 116                 forwardPath ="/updatecustomer.jsp"; 117                 //3. 将 customer 放入 request 中
                request.setAttribute("customer", customer); 119  } 120         } catch (Exception e) {} 121          //4. 响应updatecustomer.jsp 页面： 转发的形式
 request.getRequestDispatcher(forwardPath).forward(request, response); 123         
 } 125 
    private void deleteCustomer(HttpServletRequest request, 127             HttpServletResponse response) throws ServletException, IOException { 128         // 1.获取请求删除的 id 为 String 类型
        String idStr = request.getParameter("id"); 130         // try{}catch{} 的作用：方式idStr 不能转化为 int 类型，若不能转则 id = 0，无法进行任何删除
        int id = 0; 132         try { 133             // 2.将idStr 解析为int 型
            id = Integer.parseInt(idStr); 135             // 3.调用dao方法 删除数据
 customerDAO.delete(id); 137         } catch (Exception e) { 138  e.printStackTrace(); 139  } 140         response.sendRedirect("query.do"); 141 
 } 143 
    private void query(HttpServletRequest request, HttpServletResponse response) 145             throws ServletException, IOException { 146         request.setCharacterEncoding("UTF-8"); 147         String name = request.getParameter("name"); 148         String address = request.getParameter("address"); 149         String phone = request.getParameter("phone"); 150 
        CriteriaCustomer criteriaCustomer = new CriteriaCustomer(name, address, 152  phone); 153         List<Customer> lists = customerDAO 154  .getForListWithCriteriaCustomer(criteriaCustomer); 155 
        // //1.调用CustomerDAO 的getAll()方法的到Customer 集合 157         // List<Customer> lists = customerDAO.getAll(); 158         // 2.把Customer 集合放入request
        request.setAttribute("list", lists); 160         // 3.转发页面到index.jsp
        request.getRequestDispatcher("/index.jsp").forward(request, response); 162 
 } 164 
    private void addCustomer(HttpServletRequest request, 166             HttpServletResponse response) throws ServletException, IOException { 167 
        System.out.println("add function"); 169         request.setCharacterEncoding("UTF-8"); 170         // 1.获取表单参数：name，address，phone
        String name = request.getParameter("name"); 172         String address = request.getParameter("address"); 173         String phone = request.getParameter("phone"); 174 
        // 2.检验 name 是否已经被占用 176         // 2.1调用 CustomerDAO 的 getCountWithName(String name) 获取 name 在数据库中是否存在

        long rel = customerDAO.getCountWithName(name); 179         // 2.2 若返回值大于0，则响应newcustomer.jsp 页面:
        if (rel > 0) { 181             // 2.2.1 要求在newcustomer.jsp 页面显示一条消息：用户名 name 已经被占用了，请重新选择 182             // 在request 中放入一个属性 message：用户名 name 183             // 已经被占用，请重新选择！在页面通过request.getAttribute("message") 的方式来显示 184             // 2.2.2 newcustomer.jsp 的表单值可以回显 185             // value="<%= request.getParameter("name") == null ? "" : request.getParameter("name") %>" 186             // 进行回显
            request.setAttribute("message", "用户名 " + name + " 已经被占用了，请重新选择！"); 188             // 通过转发的方式来响应 newcustomer.jsp
            request.getRequestDispatcher("/newcustomer.jsp").forward(request, 190  response); 191             // 2.2.3 结束方法：return
            return; 193  } 194             // 3.把表单参数封装为一个Customer 对象
            Customer customer = new Customer(name, address, phone); 196 
            // 4.调用 customerDAO 的 save(Customer customer) 方法执行保存
 customerDAO.save(customer); 199 
            // 5.重定向到success.jsp 页面:使用重定向可以避免出现表单的重复提交
            response.sendRedirect("success.jsp"); 202  } 203     }

 

 

 

　　4）CustomerDAOXMLImpl.java

package com.jason.mvcapp.dao.impl;  2 
import java.util.List;  4 
import com.jason.mvcapp.dao.CustomerDAO;  6 import com.jsaon.mvcapp.domain.CriteriaCustomer;  7 import com.jsaon.mvcapp.domain.Customer;  8 
public class CustomerDAOXMLImpl implements CustomerDAO { 10 
 @Override 12     public List<Customer> getForListWithCriteriaCustomer( 13  CriteriaCustomer criteriaCustomer) { 14         System.out.println("CustomerDAOXMLImpl's  getForListWithCriteriaCustomer"); 15         return null; 16  } 17 
 @Override 19     public List<Customer> getAll() { 20         System.out.println("CustomerDAOXMLImpl's  getAll"); 21         return null; 22  } 23 
 @Override 25     public void save(Customer coustomer) { 26         System.out.println("CustomerDAOXMLImpl's  save"); 27  } 28 
 @Override 30     public Customer get(Integer id) { 31         System.out.println("CustomerDAOXMLImpl's  get"); 32         return null; 33  } 34 
 @Override 36     public void delete(Integer id) { 37         System.out.println("CustomerDAOXMLImpl's  get"); 38         
 } 40 
 @Override 42     public long getCountWithName(String name) { 43         System.out.println("CustomerDAOXMLImpl's  getCountWithName"); 44         return 0; 45  } 46 
 @Override 48     public void update(Customer customer) { 49         System.out.println("CustomerDAOXMLImpl's  update"); 50 
 } 52 
}

 

 

　　5）CustomerDAOJdbcImpl.java

package com.jason.mvcapp.dao.impl;  2 
import java.util.List;  4 
import com.jason.mvcapp.dao.CustomerDAO;  6 import com.jason.mvcapp.dao.DAO;  7 import com.jsaon.mvcapp.domain.CriteriaCustomer;  8 import com.jsaon.mvcapp.domain.Customer;  9 
/**
 * @author: jason 12  * @time:2016年5月25日下午3:45:06 13  * @description:对CustomerDAO 的实现 14  */
public class CustomerDAOJdbcImpl extends DAO<Customer> implements CustomerDAO { 16 
 @Override 18     public List<Customer> getAll() { 19         String sql = "SELECT * FROM customers"; 20         return getForList(sql); 21  } 22 
 @Override 24     public void save(Customer customer) { 25         String sql = "INSERT INTO customers(name, address, phone) VALUES(?,?,? )"; 26  update(sql,customer.getName(),customer.getAddress(),customer.getPhone()); 27  } 28 

 @Override 31     public Customer get(Integer id) { 32         String sql = "SELECT id, name, address, phone FROM customers WHERE id = ?"; 33         return get(sql,id); 34         
 } 36 
 @Override 38     public void delete(Integer id) { 39         String sql = "DELETE FROM customers WHERE id = ?"; 40  update(sql, id); 41  } 42 
 @Override 44     public long getCountWithName(String name) { 45         String sql = "SELECT count(id) FROM customers WHERE name = ?"; 46         return getForValue(sql, name); 47  } 48 
 @Override 50     public List<Customer> getForListWithCriteriaCustomer( 51  CriteriaCustomer criteriaCustomer) { 52         //sql语句
        String sql = "SELECT id,name,address,phone FROM customers WHERE name LIKE ? AND  address LIKE ? AND phone LIKE ?"; 54         //调用DAO<T> 中的方法getForList(),并且为占位符设置
        return getForList(sql, criteriaCustomer.getName(),criteriaCustomer.getAddress(),criteriaCustomer.getPhone()); 56  } 57 
 @Override 59     public void update(Customer customer) { 60         String sql = "UPDATE customers  SET name = ?, address = ?, phone = ? WHERE id = ?"; 61  update(sql, customer.getName(), customer.getAddress(), customer.getPhone(), customer.getId()); 62  } 63 
}

 

 

　　6）switch.properties

type=jdbc 2 #type=xml

 

 

　　7）customer.xml

<?xml version="1.0" encoding="UTF-8"?>

<customers>
    <customer id ="1001">
        <name>tom</name>
        <address>beijing</address>
        <phone>123156456</phone>
    </customer>
    
</customers>

 

 

　　8）web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>mvc</display-name>

<servlet>
    <servlet-name>InitServlet</servlet-name>
    <servlet-class>com.jason.mvcapp.servlet.InitServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>
  
  
  
</web-app>

 

 

 　　⑨）CustomerDAO.java

package com.jason.mvcapp.dao;  2 
import java.util.List;  4 
import com.jsaon.mvcapp.domain.CriteriaCustomer;  6 import com.jsaon.mvcapp.domain.Customer;  7 

/**
 * @author: jason 11  * @time:2016年5月25日下午3:28:00 12  * @description: 13  */

public interface CustomerDAO { 16 
    //带参数的模糊查询
    public List<Customer> getForListWithCriteriaCustomer(CriteriaCustomer criteriaCustomer); 19       //查询所有
    public List<Customer> getAll(); 21     
    //保存操作
    public void save(Customer coustomer); 24     
    //更新前，先查询
    public Customer get(Integer id); 27     
    //删除用户
    public void delete(Integer id); 30     
    //查看与参数相同的名字有多少个记录数
    public long getCountWithName(String name); 33     
    //更新操作
    public void update(Customer customer); 36     
}

 

 

 

　　3.总结：

　　1）从代码层次理解面向接口编程的优势