JavaWeb 三层架构
目录
一.什么是三层架构
二.三层架构的理解
三.三层架构的特征
四.为什么使用三层？
五.三层与两层的区别:
六.面向接口编程
七.实现方式
八.代码实操(用户登录)
一.什么是三层架构
表示层 ：主要是指与用户交互的界面,用于接收用户输入的数据和显示处理后用户需要的数据
业务逻辑层 ：表示层和数据库访问层之间的桥梁 , 实现业务逻辑 , 具体包含：验证、计算、业务规 则等等
数据访问层 ：与数据库打交道 , 主要实现对数据的增、删、改、查
二.三层架构的理解
生活中的三层架构 ：
顾客 ：相当于客户端
服务员 ：展示餐厅的菜品(展示数据)，相当于表示层
厨师 ：处理食材 ( 处理数据 ) ，相当于逻辑处理层
采购员 ：收购食材 ( 获取数据 ) ，相当于数据访问层
除了以上的三层外，还有一层是 entity层 ：实体层
三.三层架构的特征
各司其职 :
- 服务员就是专门和顾客直接交流的，为顾客点菜(服务员告诉厨师顾客要西红柿炒鸡蛋)
- 厨师只需要根据顾客点的菜来做 (但是厨师这里没有西红柿和鸡蛋，就把请求告诉采购员)
- 采购员只需根据顾客的菜准备食材，交给厨师即可（去仓库找一下西红柿和鸡蛋给厨师去）
三层架构 :
- 表示层就相当于服务员，专门和用户打交道，获取用户的操作
- 业务逻辑层就相当于厨师，从数据访问层拿来数据，根据表示层传来的用户操作去执行操
- 数据访问层就相当于采购员，用户需要什么数据，就从数据库或是文件中拿来此数据，交给业务逻辑层
四.为什么使用三层？
用三层架构的目的就是为了实现 高内聚低耦合 的思想:
高内聚 : 尽可能类的每个成员方法只完成一件事
低耦合 :减少类内部，一个成员方法调用另一个成员方法 （ 模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。
从类角度来看， 高内聚低耦合：减少类内部，对其他类的调用
从功能块来看, 高内聚低耦合：减少模块之间的交互复杂度
简单来说，就是 解耦 ：只做自己功能内的事
服务员（ UI 层）请假 —> 另找服务员
厨师（ BLL 层）辞职 —> 招聘另一个厨师
采购员（ DAL ）辞职 —> 招聘另一个采购员
任何一层发生变化都不会影响到另外一层!!!
三层构架的优势
职责划分清晰 ，无损替换， 复用代码 ，降低了系统内部的依赖程度，
五.三层与两层的区别:
两层 : 当任何一个地方发生变化时，都需要重新开发整个系统。
“多层 ” 放在一层，分工不明确耦合度高，难以适应需求变化，可维护性低、可扩展性低
三层 :
发生在哪一层的变化，只需更改该层，不需要更改整个系统。层次清晰，分工明确，每层之间耦合度低 ,
提高了效率，适应需求变化，可维护性高，可扩展性高
六.面向接口编程
设计与实现分开在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的, 对系统设计人员来讲就不那么重要了；而各个对象之间的协作关系则成为系 统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。
七.实现方式
biz : 存放业务逻辑层的接口
biz.impl : 存放业务逻辑层的实现类
dao : 存放数据访问层的接口
dao.impl : 存放数据访问层的实现类
八.代码实操(用户登录)
1.文件放置位置，一定要导入jar包
2.编写ulit包下方的DBHeper方法
package ulit;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import oracle.jdbc.driver.OracleDriver;
public class DBHeper {
//获取驱动
static {
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
} catch (Exception e) {
e.printStackTrace();
}
}
//编写连接语句
private static final String URL="dbc:oracle:thin:@localhost:1521:orcl";
/**
* 获得连接
* @return
*/
public static Connection getCon() {
try {
return DriverManager.getConnection(URL,"scott","zking123");
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 关闭资源
* @param con
* @param ps
* @param rs
*/
public static void getClose(Connection con,PreparedStatement ps,ResultSet rs) {
try {
if(con!=null&&con.isClosed())con.close();
if(ps!=null)ps.close();
if(rs!=null)rs.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
2.编写pojo包
package pojo;
public class UserPojo {
private int id;
private String name;
private String pwd;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public UserPojo() {
}
public UserPojo(int id, String name, String pwd) {
super();
this.id = id;
this.name = name;
this.pwd = pwd;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((pwd == null) ? 0 : pwd.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
UserPojo other = (UserPojo) obj;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (pwd == null) {
if (other.pwd != null)
return false;
} else if (!pwd.equals(other.pwd))
return false;
return true;
}
}
3.编写用户业务逻辑层的接口（IUserBiz），放在biz包下方
package biz;
import pojo.UserPojo;
/**
* 接口(业务逻辑层)
* @author zjjt
*
*/
public interface IUserBiz {
String Login(UserPojo user);
}
4.编写用户业务逻辑层的实现类(UserBizImpl)，放在biz.impl包下方，实现接口IUserBiz
该代码中 用了用户的数据库操作接口实现类（UserDaoImpl），在这里进行了一个判断，判断该用户是否存在
package biz.impl;
/**
* 业务逻辑层的实体类
*/
import biz.IUserBiz;
import dao.IUserDao;
import dao.impl.UserDaoImpl;
import pojo.UserPojo;
public class UserBizImpl implements IUserBiz{
private IUserDao userdao=new UserDaoImpl();
public String Login(UserPojo user) {
//先拿到dao包的数据
UserPojo u=userdao.select(user);
if(u!=null) {
return "登录成功";
}else {
return "登录失败";
}
}
}
5.编写用户用户的数据库操作接口（IUserDao），放在Dao包下方
package dao;
/*
* 存放数据访问层的接口
*/
import pojo.UserPojo;
public interface IUserDao {
UserPojo select(UserPojo user);
}6.编写用户的数据库操作接口实现类（UserDaoImpl），放在dao.impl包下方,实现接口IUserDao
package dao.impl;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import org.apache.tomcat.jni.User;
/**
* 存放数据访问层的实现类
*/
import dao.IUserDao;
import pojo.UserPojo;
import ulit.DBHeper;
public class UserDaoImpl implements IUserDao {
private Connection con;
private PreparedStatement ps;
private ResultSet rs;
public UserPojo select(UserPojo user) {
try {
con=DBHeper.getCon();
ps=con.prepareStatement("select * from jw05_user where uname=? and upwd=?");
ps.setString(1,user.getName());
ps.setString(2,user.getPwd());
rs=ps.executeQuery();
while(rs.next()) {
UserPojo u=new UserPojo();
u.setId(rs.getInt(1));
u.setName(rs.getString(2));
u.setPwd(rs.getString(3));
return u;
}
} catch (Exception e) {
e.printStackTrace();
}finally {
DBHeper.getClose(con, ps, rs);
}
return null;
}
}
7.登录界面
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
Insert title here
8.判断是否登录成功界面.
我们直接调用用户业务逻辑层的实现类(UserBizImpl)，按照以前我们肯定是用dao包中的方法，进行判断学生是否存在，但是我们的用户业务逻辑层的实现类(UserBizImpl)，他已经帮我们进行了判断学生是否存在，我们直接调用用户业务逻辑层的实现类(UserBizImpl)，就可以了。
<%@page import="biz.impl.UserBizImpl"%>
<%@page import="biz.IUserBiz"%>
<%@page import="dao.impl.UserDaoImpl"%>
<%@page import="pojo.UserPojo"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%
//拿到数据
String name=request.getParameter("username");
String pwd=request.getParameter("userpwd");
UserPojo u=new UserPojo(0,name,pwd);
//登录
//里氏替换原则
IUserBiz uimpl=new UserBizImpl();
String message=uimpl.Login(u);
out.print(message);
%>今天的学习也就告一段落啦，大家跟着上方提供的代码去敲一遍，要理解意思哦。