本博客为原创：综合 尚硅谷（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; import java.util.HashMap;
import java.util.Map; import com.jason.mvcapp.dao.CustomerDAO;
import com.jason.mvcapp.dao.impl.CustomerDAOJdbcImpl;
import com.jason.mvcapp.dao.impl.CustomerDAOXMLImpl; /***
*
* @author: jason
* @time:2016年5月28日下午5:37:39
* @description:单例的 CustomerDAO 工场类。采用饿汉式，线程安全
*/
public class CustomerDAOFactory { private Map<String , CustomerDAO> daos = new HashMap<String, CustomerDAO>(); //1.私有化构造器
private CustomerDAOFactory(){ daos.put("jdbc", new CustomerDAOJdbcImpl());
daos.put("xml", new CustomerDAOXMLImpl()); }
//2.创建一个静态的实例
private static CustomerDAOFactory instance = new CustomerDAOFactory();
//3.提供获取实例的方法
public static CustomerDAOFactory getInstance() {
return instance;
} private static String type = null; public void setType(String type) {
this.type = type;
} public static String getType() {
return type;
}
public CustomerDAO getCustomerDAO(){ return daos.get(type);
} }
2）InitServlet.java
package com.jason.mvcapp.servlet; import java.io.IOException;
import java.io.InputStream;
import java.util.Properties; import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet; import com.jason.mvcapp.dao.factory.CustomerDAOFactory; /**
* Servlet implementation class InitServlet
*/
@WebServlet("/InitServlet")
public class InitServlet extends HttpServlet { private static final long serialVersionUID = 1L; @Override
public void init() throws ServletException {
CustomerDAOFactory.getInstance().setType("jdbc"); //1.读取类路径下的switch.properties 配置文件
InputStream is = getServletContext().getResourceAsStream("/WEB-INF/classes/switch.properties"); Properties properties = new Properties();
try {
properties.load(is); //2.获取switch.properties 的type 值
String type = properties.getProperty("type"); //3.赋值给CustomerDAOFactory 的type 属性
CustomerDAOFactory.getInstance().setType(type); } catch (IOException e) {
e.printStackTrace();
}
} }
3）CustomerServlet2.java
package com.jason.mvcapp.servlet; import java.io.IOException;
import java.lang.reflect.Method;
import java.util.List; import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; import com.jason.mvcapp.dao.CustomerDAO;
import com.jason.mvcapp.dao.factory.CustomerDAOFactory;
import com.jason.mvcapp.dao.impl.CustomerDAOJdbcImpl;
import com.jsaon.mvcapp.domain.CriteriaCustomer;
import com.jsaon.mvcapp.domain.Customer; /**
* Servlet implementation class CustomerServlet2
*/
@WebServlet("*.do")
public class CustomerServlet2 extends HttpServlet {
private static final long serialVersionUID = 1L; // 创建一个CustomerDAO对象，多态
27 private CustomerDAO customerDAO = CustomerDAOFactory.getInstance().getCustomerDAO();
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
doPost(request, response);
} protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
// 1.获取servletPath：/add.do 或者 query.do
String serveltPath = request.getServletPath(); // System.out.println(serveltPath);
// 2.去除/ 和 .do 得到对应的方法，如 add query
String methodName = serveltPath.substring(1);
methodName = methodName.substring(0, methodName.length() - 3);
// System.out.println(methodName); try {
// 3.利用反射获取methodName对应的方法
Method method = getClass().getDeclaredMethod(methodName,
HttpServletRequest.class, HttpServletResponse.class); // 4.利用反射调用方法
method.invoke(this, request, response);
} catch (Exception e) { e.printStackTrace();
}
} private void updateCustomer(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
System.out.println("update");
request.setCharacterEncoding("UTF-8"); //1.获取请求信息：id，name，address，phone，oldName //1.1 隐藏域的 值
String idStr = request.getParameter("id");
String oldNameStr = request.getParameter("oldName"); //1.2 提交的值
String nameStr = request.getParameter("name");
String addressStr = request.getParameter("address");
String phoneStr = request.getParameter("phone"); //2.验证name 是否可用
//通过equalsIgnoreCase() 方式 避免了 大小写的问题。equals 方法区分大小写， 而数据库SQL 不区分大小写
if(!oldNameStr.equalsIgnoreCase(nameStr)){
//2.1 先比较name 和 oldName 是否相同，若相同，说明name 可用
//2.2 若不相同，则调用CustomerDAO 的getCostomerWithName(String name) 获取 name 在数据库中是否存在
long rel = customerDAO.getCountWithName(nameStr);
//2.2.1 若存在，则返回值大于 0，则响应 updatecustomer.jsp 页面：通过转发的方式
if(rel > 0){
// 进行回显字符串，在request 中放入一个属性 message：用户名 name
// 回显：updatecustomer.jsp 的表单值可以回显
// value="<%= request.getParameter("name") == null ? "" : request.getParameter("name") %>" 进行回显
// 注意：name 显示的是 oldName，而address 和 phone 显示的是新的
request.setAttribute("message", "用户名 " + nameStr + " 已经被占用了，请重新选择！");
//2.2.2 存在，要求在updatecustomer.jsp 页面显示一条消息：用户名 name 已经被占用了，请重新选择
request.getRequestDispatcher("/updatecustomer.jsp").forward(request,response);
// 2.2.3 结束方法：return
return;
}
} //3.通过验证后，则将表单封装为一个Customer 对象 customer
Customer customer = new Customer(nameStr, addressStr, phoneStr);
customer.setId(Integer.parseInt(idStr)); //4.调用CustomerDAO 的save(Customer customer) 执行更新操作
customerDAO.update(customer); //5.重定向到 query.do
response.sendRedirect("query.do"); } private void editeCustomer(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
System.out.println("edit");
String forwardPath = "/error.jsp";
//1. 获取请求参数id
String idStr = request.getParameter("id");
try {
//2. 调用CustomerDAO 的get(id) 方法，获取 和id 对应的Customer 对象
Customer customer = customerDAO.get(Integer.parseInt(idStr));
if(customer != null){
forwardPath ="/updatecustomer.jsp";
//3. 将 customer 放入 request 中
request.setAttribute("customer", customer);
}
} catch (Exception e) {}
//4. 响应updatecustomer.jsp 页面： 转发的形式
request.getRequestDispatcher(forwardPath).forward(request, response); } private void deleteCustomer(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
// 1.获取请求删除的 id 为 String 类型
String idStr = request.getParameter("id");
// try{}catch{} 的作用：方式idStr 不能转化为 int 类型，若不能转则 id = 0，无法进行任何删除
int id = 0;
try {
// 2.将idStr 解析为int 型
id = Integer.parseInt(idStr);
// 3.调用dao方法 删除数据
customerDAO.delete(id);
} catch (Exception e) {
e.printStackTrace();
}
response.sendRedirect("query.do"); } private void query(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.setCharacterEncoding("UTF-8");
String name = request.getParameter("name");
String address = request.getParameter("address");
String phone = request.getParameter("phone"); CriteriaCustomer criteriaCustomer = new CriteriaCustomer(name, address,
phone);
List<Customer> lists = customerDAO
.getForListWithCriteriaCustomer(criteriaCustomer); // //1.调用CustomerDAO 的getAll()方法的到Customer 集合
// List<Customer> lists = customerDAO.getAll();
// 2.把Customer 集合放入request
request.setAttribute("list", lists);
// 3.转发页面到index.jsp
request.getRequestDispatcher("/index.jsp").forward(request, response); } private void addCustomer(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException { System.out.println("add function");
request.setCharacterEncoding("UTF-8");
// 1.获取表单参数：name，address，phone
String name = request.getParameter("name");
String address = request.getParameter("address");
String phone = request.getParameter("phone"); // 2.检验 name 是否已经被占用
// 2.1调用 CustomerDAO 的 getCountWithName(String name) 获取 name 在数据库中是否存在 long rel = customerDAO.getCountWithName(name);
// 2.2 若返回值大于0，则响应newcustomer.jsp 页面:
if (rel > 0) {
// 2.2.1 要求在newcustomer.jsp 页面显示一条消息：用户名 name 已经被占用了，请重新选择
// 在request 中放入一个属性 message：用户名 name
// 已经被占用，请重新选择！在页面通过request.getAttribute("message") 的方式来显示
// 2.2.2 newcustomer.jsp 的表单值可以回显
// value="<%= request.getParameter("name") == null ? "" : request.getParameter("name") %>"
// 进行回显
request.setAttribute("message", "用户名 " + name + " 已经被占用了，请重新选择！");
// 通过转发的方式来响应 newcustomer.jsp
request.getRequestDispatcher("/newcustomer.jsp").forward(request,
response);
// 2.2.3 结束方法：return
return;
}
// 3.把表单参数封装为一个Customer 对象
Customer customer = new Customer(name, address, phone); // 4.调用 customerDAO 的 save(Customer customer) 方法执行保存
customerDAO.save(customer); // 5.重定向到success.jsp 页面:使用重定向可以避免出现表单的重复提交
response.sendRedirect("success.jsp");
}
}
4）CustomerDAOXMLImpl.java
package com.jason.mvcapp.dao.impl; import java.util.List; import com.jason.mvcapp.dao.CustomerDAO;
import com.jsaon.mvcapp.domain.CriteriaCustomer;
import com.jsaon.mvcapp.domain.Customer; public class CustomerDAOXMLImpl implements CustomerDAO { @Override
public List<Customer> getForListWithCriteriaCustomer(
CriteriaCustomer criteriaCustomer) {
System.out.println("CustomerDAOXMLImpl's getForListWithCriteriaCustomer");
return null;
} @Override
public List<Customer> getAll() {
System.out.println("CustomerDAOXMLImpl's getAll");
return null;
} @Override
public void save(Customer coustomer) {
System.out.println("CustomerDAOXMLImpl's save");
} @Override
public Customer get(Integer id) {
System.out.println("CustomerDAOXMLImpl's get");
return null;
} @Override
public void delete(Integer id) {
System.out.println("CustomerDAOXMLImpl's get"); } @Override
public long getCountWithName(String name) {
System.out.println("CustomerDAOXMLImpl's getCountWithName");
return 0;
} @Override
public void update(Customer customer) {
System.out.println("CustomerDAOXMLImpl's update"); } }
5）CustomerDAOJdbcImpl.java
package com.jason.mvcapp.dao.impl; import java.util.List; import com.jason.mvcapp.dao.CustomerDAO;
import com.jason.mvcapp.dao.DAO;
import com.jsaon.mvcapp.domain.CriteriaCustomer;
import com.jsaon.mvcapp.domain.Customer; /**
* @author: jason
* @time:2016年5月25日下午3:45:06
* @description:对CustomerDAO 的实现
*/
public class CustomerDAOJdbcImpl extends DAO<Customer> implements CustomerDAO { @Override
public List<Customer> getAll() {
String sql = "SELECT * FROM customers";
return getForList(sql);
} @Override
public void save(Customer customer) {
String sql = "INSERT INTO customers(name, address, phone) VALUES(?,?,? )";
update(sql,customer.getName(),customer.getAddress(),customer.getPhone());
} @Override
public Customer get(Integer id) {
String sql = "SELECT id, name, address, phone FROM customers WHERE id = ?";
return get(sql,id); } @Override
public void delete(Integer id) {
String sql = "DELETE FROM customers WHERE id = ?";
update(sql, id);
} @Override
public long getCountWithName(String name) {
String sql = "SELECT count(id) FROM customers WHERE name = ?";
return getForValue(sql, name);
} @Override
public List<Customer> getForListWithCriteriaCustomer(
CriteriaCustomer criteriaCustomer) {
//sql语句
String sql = "SELECT id,name,address,phone FROM customers WHERE name LIKE ? AND address LIKE ? AND phone LIKE ?";
//调用DAO<T> 中的方法getForList(),并且为占位符设置
return getForList(sql, criteriaCustomer.getName(),criteriaCustomer.getAddress(),criteriaCustomer.getPhone());
} @Override
public void update(Customer customer) {
String sql = "UPDATE customers SET name = ?, address = ?, phone = ? WHERE id = ?";
update(sql, customer.getName(), customer.getAddress(), customer.getPhone(), customer.getId());
} }
6）switch.properties
type=jdbc
#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; import java.util.List; import com.jsaon.mvcapp.domain.CriteriaCustomer;
import com.jsaon.mvcapp.domain.Customer; /**
* @author: jason
* @time:2016年5月25日下午3:28:00
* @description:
*/ public interface CustomerDAO { //带参数的模糊查询
public List<Customer> getForListWithCriteriaCustomer(CriteriaCustomer criteriaCustomer);
//查询所有
public List<Customer> getAll(); //保存操作
public void save(Customer coustomer); //更新前，先查询
public Customer get(Integer id); //删除用户
public void delete(Integer id); //查看与参数相同的名字有多少个记录数
public long getCountWithName(String name); //更新操作
public void update(Customer customer); }
3.总结：
1）从代码层次理解面向接口编程的优势