经典三层构架
前言
三层架构就是为了符合“高内聚，低耦合”思想，把各个功能模块划分为表示层（UI）、
业务逻辑层（BLL）和数据访问层（DAL）三层架构，各层之间采用接口相互访问，
并通过对象模型的实体类（Model）作为数据传递的载体，不同的对象模型的实体类
一般对应于数据库的不同表，实体类的属性与数据库表的字段名一致。
三层架构区分层次的目的是为了 “高内聚，低耦合”。开发人员分工更明确，将精力更
专注于应用系统核心业务逻辑的分析、设计和开发，加快项目的进度，提高了开发效率
有利于项目的更新和维护工作。
User
： 这里我们进行的是数据的封装，也就是我们所说的 Javabean
//（1）JavaBean 类必须是一个公共类，并将其访问属性设置为 public
//（2）JavaBean 类必须有一个空的构造函数：类中必须有一个不带参数的公用构造器，
// 此构造器也应该通过调用各个特性的设置方法来设置特性的缺省值。
//（3）一个javaBean类不应有公共实例变量，类变量都为private
//（4）持有值应该通过一组存取方法（getXxx 和 setXxx）来访问：
// 对于每个特性，应该有一个带匹配公用 getter 和 setter 方法的专用实例变量。
//若是布尔值，可以用isXxx来代替getXxx。
//(5)属性的第二个字母最好不要大写， 像rCategory, hFilename之类，生成getter 和setter会有问题。
import java.io.Serializable;
//符合公共类
public class User implements Serializable{
//类变量 都为 private
private int id;
private String username;
private String password;
private String nickname;
private String email;
//空的构造函数
public User() {
super();
// TODO Auto-generated constructor stub
}
//构造器
public User(int id, String username, String password, String nickname, String email) {
super();
this.id = id;
this.username = username;
this.password = password;
this.nickname = nickname;
this.email = email;
}
//get set 方法
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
//toString
@Override
public String toString() {
return "User [id=" + id + ", username=" + username + ", password=" + password + ", nickname=" + nickname
+ ", email=" + email + "]";
}
}
MsgException
: 自定义异常
//自定义异常 要继承 其父类
public class MsgException extends Exception{
//
public MsgException(){
super();
}
public MsgException(String message,Throwable cause){
super(message,cause);
}
public MsgException(String message){
super(message);
}
}
Factory
:
//
public class UserDaoFactory{
//
private UserDaoFactory(){}
//设置静态对象
private static UserDaoFactory factory = new UserDaoFactory();
//设置静态方法
public static UserDaoFactory getFactory(){
return factory;
}
//获取 UserDao 的方法
public UserDao getUserDao(){
return new UserDaoImpl();
}
}
//第二个类
public class UserServiceFactory{
//
private UserServiceFactory(){}
//设置静态对象
private static UserServiceFactory factory = new UserServiceFactory();
//设置静态方法
public static UserServiceFactory getFactory(){
return factory;
}
//获取 UserService 方法
public UserService getUserService(){
return new UserServiceImpl();
}
}
Service
:
public interface UserService{
boolean hasUsername(String username);
boolean registUser(User user);
User login(String username,String password) throws MsgException;
}
//
public class UserServiceImpl UserService{
private UserDao userDao = UserDaoFactory.getFactory().getUserDao();
//
@Override
public boolean hasUsername(String username){
boolean flag = uerDao.getUserByUsername(username);
return flag;
}
@Override
public boolean registUser(User user){
boolean flag = userDao.saveUser(user);
return flag;
}
@Override
public User login(String usernmae,String password) throws MsgException{
User user = userDao.getUserByUAP(username,password);
return user;
}
}
DAO层
： 属于 javaEE 经典三层架构中的 M层（model（模型）负责数据的操作，数据的封装，数据的持久化）
代码块
：我们在 dao 中会书写两个类
//dao代码
//在 dao代码中 我们写的是接口
//查一个用户名字
//多个使用方法（listxxxgetxxx()）
//interface（接口） : 是面向对象编程语言中接口操作的关键字，
//功能是把所需成员组合起来，用来装封一定功能的集合。
//它好比一个模板，在其中定义了对象必须实现的成员，通过类或结构来实现它。
//接口不能直接实例化，即ICount ic=new iCount()是错的。
//接口不能包含成员的任何代码，只定义成员本身。
//接口成员的具体代码由实现接口的类提供。接口使用interface关键字进行声明
public interface UserDao{
boolean getUserByUsername(String username);
//保存用户信息
boolean saveUser(User user);
//根据用户名和密码查询用户信息的方法
User getUserByUAP(String username, String
password)throws MsgExceprion;
}
//第二个类
//daoImpl
//我们在该类中写的实现dao中写的接口的方法
//implements ：是实现多个接口, 接口的方法一般为空的, 必须重写才能使用
//该部分代码我们是获取数据库中信息
@Override
public boolean getUserByUsername(String username){
/*
1、加载驱动程序；
2、连接数据库；
3、访问数据库；
4、执行查询；
*/
//将数据库查询的用户名 赋值给 sql
String sql = "select * from user where username=?";
//连接数据库查询前定义几个变量
//连接数据库
Connection conn = null;
//.PreparedStatement是预编译的,对于批量处理可以大大提高效率. 也叫JDBC存储过程
PreparedStatement ps = null;
//结果存储
Request rs = null;
//
try{
//获取数据库的连接
conn = JDBCUtils.getConnection();
//获取数据库中的用户名
ps.setString(1,username);
//executeQuery()方法会把数据库响应的查询结果存放在ResultSet类对象中供我们使用
rs= ps.executQuery();
//判断
//.next()方法的作用：指针指向下一条记录，有记录（有值）返回true并把记录内容存入到对应的对象中，
//也就是obj.next()的obj中。如果没有返回false。
//.next()方法的应用：一般和ResultSet对象和while循环一起使用，去迭代结果集，
//并在循环中调用getXXX(intfieldIndex)/getXXX(String columnName)方法获取字段值。
//过程：ResultSet对象具有指向其当前数据行的指针。开始，指针被置于第一行。
//.next()方法将指针移动到下一行，然后while循环迭代遍历ResultSet对象。
if(rs.next()){
return true;
}
//出现异常时输出
}catch(Exception e){
e.printStackTrace();
//关闭数据库
}finally {
JDBCUtils.close(conn,ps,rs);
}
return false;
}
//第二部分
//该部分代码我们是将代码保存到数据库中
@Override
public boolean saveUser(User user){
// 将插入内容定义 并赋值给 sql
String sql = "insert into values(null,?,?,?,?)";
//获取数据库连接
Coonection conn = null;
//.PreparedStatement是预编译的,对于批量处理可以大大提高效率. 也叫JDBC存储过程
PrepareStatement ps = null;
try{
//连接到数据库
conn = JDBCUtils.getConnection();
//存储数据
ps.setString(1,user.getUsername());
ps.setString(2,user.getPassword());
ps.setString(3,user.getNickname());
ps.setString(4,user.getEmail());
//增、删、改 用executeUpdate（）,返回值为int型，表示被影响的行数
int i = ps.executeUpdate();
if(i>0){
return true;
}
}catch(Exception e){
e.printStackTrace();
}finally{
JDBCUtils.close(conn,ps,null);
}
return false;
}
//第三部分
//该部分代码是查看数据库中是够有重复
@Override
public User getUserByUAP(String username,String password) throws MsgException{
//将查找内容赋值给 sql
String sql = "select * from user where username=? and password=?";
//定义数据库
Connection conn =null;
PrepareStatement ps = null;
ResultSet rs = null;
User user = null;
//连接数据库
try{
//连接数据库
conn = JDBCUtils.getConnection();
//存储该语句所得到的信息
ps = conn.prepareStatement(sql);
//存储用户名
ps.setString(1,username);
//存储密码
ps.setString(2,password);
//executeQuery()方法会把数据库响应的查询结果存放在ResultSet类对象中供我们使用。
rs = ps.executeQuery();
//判断
//.next() 的方法作用上面有详细解释
if(rs.next()){
user = new User();
//获取参数
user.setId(rs.getInt("id"));
user.setUsername(rs.getString("username"));
user.setPassword(rs.getString("password"));
user.setNickname(rs.getString("nickname"));
user.setEmail(rs.getString("email"));
}
}catch (Exception e){
e.printStackTrace();
//通过异常的抛出机制（一个方法抛出异常，如果没有被捕获，会自动返回给它的调用者）--》抛出自定义异常，传递消息
throw new MsgException("登录时服务器出现异常，请稍后尝试");
}finally{
JDBCUtils.close(conn,ps,rs);
}
return user;
}