Member类作为数据功能类
package cn.mldn.oracle.vo;
import java.io.Serializable;
import java.util.Date;
@SuppressWarnings("serial")
public class Member implements Serializable {
private String mid ;
private String name ;
private Integer age ;
private String phone ;
private Date birthday ;
private String note ;
// setter、getter略
public String getMid() {
return mid;
}
public void setMid(String mid) {
this.mid = mid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getNote() {
return note;
}
public void setNote(String note) {
this.note = note;
}
@Override
public String toString() {
return "Member [mid=" + mid + ", name=" + name + ", age=" + age + ", phone=" + phone + ", birthday=" + birthday
+ ", note=" + note + "]";
}
}
DatebaseConnection：数据库连接实现
package cn.mldn.oracle.dbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import javax.xml.crypto.Data;
/**
* 本类负责Oracle数据库的连接与打开操作处理
* 一旦实例化本类对象，将自动取得相对应的数据库连接
* @author mldn
*/
public class DatabaseConnection {
private static final String DBDRIVER = "oracle.jdbc.driver.OracleDriver" ;
private static final String DBURL = "jdbc:oracle:thin:@localhost:1521:MLDN" ;
private static final String DBUSER = "scott" ;
private static final String PASSWORD = "tiger" ;
private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>() ;
private DatabaseConnection() {}
/**
* 取得一个Connection接口对象
* @return Connection对象
*/
private static Connection rebuildConnection() {
try {
Class.forName(DBDRIVER) ;
return DriverManager.getConnection(DBURL, DBUSER, PASSWORD) ;
} catch (Exception e) {
e.printStackTrace();
}
return null ;
}
/**
* 取得一个Connection对象，是通过ThreadLocal类对象取得，每一个线程存放自己的对象
* @return 返回一个连接对象
*/
public static Connection getConnection() {
Connection conn = threadLocal.get() ; // 取得一个Connection
if (conn == null) { // 表示现在还没有创建Connection，ThreadLocal没有保存数据
conn = rebuildConnection() ; // 建立新的数据库连接对象
threadLocal.set(conn); // 保存对象
}
return conn ;
}
/**
* 关闭数据库连接
*/
public static void close() {
Connection conn = threadLocal.get() ; // 取得保存的对象
if (conn != null) { // 现在还有连接对象
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
threadLocal.remove(); // 清空ThreadLocal原本的内容
}
}
}
进行数据层接口实现
package cn.mldn.oracle.dao;
import java.util.List;
import java.util.Set;
/**
* 定义member数据表的数据层操作标准
* @author mldn
*/
public interface IDAO<K,V> {
/**
* 保存member数据表中的数据
* @param vo 要保存数据的VO对象
* @return 保存成功返回true，否则返回false
* @throws Exception 数据库未连接，或者数据库操作错误
*/
public boolean doCreate(V vo) throws Exception ;
/**
* 进行member表数据的修改，本次修改是基于id的修改处理
* @param vo 要修改的全部数据
* @return 修改成功返回true，否则返回false
* @throws Exception 数据库未连接，或者数据库操作错误
*/
public boolean doUpdate(V vo) throws Exception ;
/**
* 数据的删除处理，会将所有要删除的数据保存在Set集合之中
* @param ids 所有要删除的ID编号
* @return 如果要删除的数量符合于最终的执行标准返回true，否则返回false
* @throws Exception 数据库未连接，或者数据库操作错误
*/
public boolean doRemoveBatch(Set<K> ids) throws Exception ;
/**
* 根据id查询出一个用户的完整信息
* @param id 要查询的用户id
* @return 如果数据找到则以VO类对象的形式返回，返回null
* @throws Exception 数据库未连接，或者数据库操作错误
*/
public V findById(K id) throws Exception ;
/**
* 查询数据表中的全部数据
* @return 会返回多个Member对象，将以List的集合形式返回。
* 如果表中没有数据则返回的List集合长度为0（size() == 0）
* @throws Exception 数据库未连接，或者数据库操作错误
*/
public List<V> findAll() throws Exception ;
/**
* 数据的分页显示处理
* @param currentPage 当前所在页
* @param lineSize 每页显示的数据行数
* @return 会返回多个Member对象，将以List的集合形式返回。
* 如果表中没有数据则返回的List集合长度为0（size() == 0）
* @throws Exception 数据库未连接，或者数据库操作错误
*/
public List<V> findAllSplit(Integer currentPage,Integer lineSize) throws Exception ;
/**
* 数据的分页查询显示处理
* @param column 需要进行查询的数据列
* @param keyWord 要查询的关键字，如果关键字为空字符串表示查询全部
* @param currentPage 当前所在页
* @param lineSize 每页显示的数据行数
* @return 会返回多个Member对象，将以List的集合形式返回。
* 如果表中没有数据则返回的List集合长度为0（size() == 0）
* @throws Exception 数据库未连接，或者数据库操作错误
*/
public List<V> findAllSplit(String column, String keyWord, Integer currentPage, Integer lineSize)
throws Exception;
/**
* 统计数据表中的全部数据量
* @return 使用COUNT()函数的统计结果
* @throws Exception 数据库未连接，或者数据库操作错误
*/
public Long getAllCount() throws Exception ;
/**
* 统计模糊查询的数据量
* @param column需要进行查询的数据列
* @param keyWord 要查询的关键字，如果关键字为空字符串表示查询全部
* @return 使用COUNT()函数的统计结果
* @throws Exception 数据库未连接，或者数据库操作错误
*/
public Long getAllCount(String column,String keyWord) throws Exception ;
}
数据层用户借口实现
package cn.mldn.oracle.dao;
import cn.mldn.oracle.vo.Member;
/**
* 定义member数据表的数据层操作标准
* @author mldn
*/
public interface IMemberDAO extends IDAO<String,Member> {
/**
* 根据电话查找用户信息是否存在
* @param phone 要查找的电话
* @return 查找到数据返回Member，否则返回null
* @throws Exception 数据库未连接，或者数据库操作错误
*/
public Member findByPhone(String phone) throws Exception ;
}
数据层确切描述类
package cn.mldn.oracle.dao.impl;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import cn.mldn.oracle.dao.IMemberDAO;
import cn.mldn.oracle.dbc.DatabaseConnection;
import cn.mldn.oracle.vo.Member;
public class MemberDAOImpl implements IMemberDAO {
private Connection conn ;
private PreparedStatement pstmt ; // 所有的数据库的操作都通过此接口完成
public MemberDAOImpl() {
this.conn = DatabaseConnection.getConnection() ;
}
@Override
public boolean doCreate(Member vo) throws Exception {
String sql = "INSERT INTO member(mid,name,age,phone,birthday,note) VALUES (?,?,?,?,?,?) " ;
this.pstmt = this.conn.prepareStatement(sql) ;
this.pstmt.setString(1, vo.getMid());
this.pstmt.setString(2, vo.getName());
this.pstmt.setInt(3, vo.getAge());
this.pstmt.setString(4, vo.getPhone());
this.pstmt.setDate(5, new java.sql.Date(vo.getBirthday().getTime()));
this.pstmt.setString(6, vo.getNote());
return this.pstmt.executeUpdate() > 0 ;
}
@Override
public boolean doUpdate(Member vo) throws Exception {
String sql = "UPDATE member SET name=?,age=?,phone=?,birthday=?,note=? WHERE mid=?" ;
this.pstmt = this.conn.prepareStatement(sql) ;
this.pstmt.setString(1, vo.getName());
this.pstmt.setInt(2, vo.getAge());
this.pstmt.setString(3, vo.getPhone());
this.pstmt.setDate(4, new java.sql.Date(vo.getBirthday().getTime()));
this.pstmt.setString(5, vo.getNote());
this.pstmt.setString(6, vo.getMid());
return this.pstmt.executeUpdate() > 0 ;
}
@Override
public boolean doRemoveBatch(Set<String> ids) throws Exception {
StringBuffer buf = new StringBuffer() ; // 需要频繁修改字符串
buf.append("DELETE FROM member WHERE mid IN (") ;
Iterator<String> iter = ids.iterator() ;
while (iter.hasNext()) {
buf.append("'").append(iter.next()).append("'").append(",") ;
}
buf.delete(buf.length() - 1, buf.length()).append(")") ;
this.pstmt = this.conn.prepareStatement(buf.toString()) ;
return this.pstmt.executeUpdate() == ids.size();
}
@Override
public Member findById(String id) throws Exception {
Member vo = null ;
String sql = "SELECT mid,name,age,phone,birthday,note FROM member WHERE mid=?" ;
this.pstmt = this.conn.prepareStatement(sql) ;
this.pstmt.setString(1, id);
ResultSet rs = this.pstmt.executeQuery() ;
if (rs.next()) { // 如果有数据返回则进行对象实例化
vo = new Member() ;
vo.setMid(rs.getString(1));
vo.setName(rs.getString(2));
vo.setAge(rs.getInt(3));
vo.setPhone(rs.getString(4));
vo.setBirthday(rs.getDate(5));
vo.setNote(rs.getString(6));
}
return vo;
}
@Override
public Member findByPhone(String phone) throws Exception {
Member vo = null ;
String sql = "SELECT mid,name,age,phone,birthday,note FROM member WHERE phone=?" ;
this.pstmt = this.conn.prepareStatement(sql) ;
this.pstmt.setString(1, phone);
ResultSet rs = this.pstmt.executeQuery() ;
if (rs.next()) { // 如果有数据返回则进行对象实例化
vo = new Member() ;
vo.setMid(rs.getString(1));
vo.setName(rs.getString(2));
vo.setAge(rs.getInt(3));
vo.setPhone(rs.getString(4));
vo.setBirthday(rs.getDate(5));
vo.setNote(rs.getString(6));
}
return vo;
}
@Override
public List<Member> findAll() throws Exception {
List<Member> all = new ArrayList<Member>() ;
String sql = "SELECT mid,name,age,phone,birthday,note FROM member" ;
this.pstmt = this.conn.prepareStatement(sql) ;
ResultSet rs = this.pstmt.executeQuery() ;
while (rs.next()) {
Member vo = new Member() ;
vo.setMid(rs.getString(1));
vo.setName(rs.getString(2));
vo.setAge(rs.getInt(3));
vo.setPhone(rs.getString(4));
vo.setBirthday(rs.getDate(5));
vo.setNote(rs.getString(6));
all.add(vo) ;
}
return all;
}
@Override
public List<Member> findAllSplit(Integer currentPage, Integer lineSize) throws Exception {
List<Member> all = new ArrayList<Member>() ;
String sql = "SELECT * FROM ( "
+ " SELECT mid,name,age,phone,birthday,note,ROWNUM rn "
+ " FROM member WHERE ROWNUM<=?) temp"
+ " WHERE temp.rn>?" ;
this.pstmt = this.conn.prepareStatement(sql) ;
this.pstmt.setInt(1, currentPage * lineSize);
this.pstmt.setInt(2, (currentPage - 1) * lineSize);
ResultSet rs = this.pstmt.executeQuery() ;
while (rs.next()) {
Member vo = new Member() ;
vo.setMid(rs.getString(1));
vo.setName(rs.getString(2));
vo.setAge(rs.getInt(3));
vo.setPhone(rs.getString(4));
vo.setBirthday(rs.getDate(5));
vo.setNote(rs.getString(6));
all.add(vo) ;
}
return all;
}
@Override
public List<Member> findAllSplit(String column, String keyWord, Integer currentPage, Integer lineSize)
throws Exception {
List<Member> all = new ArrayList<Member>() ;
String sql = "SELECT * FROM ( "
+ " SELECT mid,name,age,phone,birthday,note,ROWNUM rn "
+ " FROM member WHERE "+column+" LIKE ? AND ROWNUM<=?) temp"
+ " WHERE temp.rn>?" ;
this.pstmt = this.conn.prepareStatement(sql) ;
this.pstmt.setString(1, "%" + keyWord + "%");
this.pstmt.setInt(2, currentPage * lineSize);
this.pstmt.setInt(3, (currentPage - 1) * lineSize);
ResultSet rs = this.pstmt.executeQuery() ;
while (rs.next()) {
Member vo = new Member() ;
vo.setMid(rs.getString(1));
vo.setName(rs.getString(2));
vo.setAge(rs.getInt(3));
vo.setPhone(rs.getString(4));
vo.setBirthday(rs.getDate(5));
vo.setNote(rs.getString(6));
all.add(vo) ;
}
return all;
}
@Override
public Long getAllCount() throws Exception {
String sql = "SELECT COUNT(*) FROM member" ;
this.pstmt = this.conn.prepareStatement(sql) ;
ResultSet rs = this.pstmt.executeQuery() ;
if (rs.next()) {
return rs.getLong(1) ;
}
return 0L ;
}
@Override
public Long getAllCount(String column, String keyWord) throws Exception {
String sql = "SELECT COUNT(*) FROM member WHERE " + column + " LIKE ?" ;
this.pstmt = this.conn.prepareStatement(sql) ;
this.pstmt.setString(1, "%" + keyWord + "%");
ResultSet rs = this.pstmt.executeQuery() ;
if (rs.next()) {
return rs.getLong(1) ;
}
return 0L ;
}
}
数据层工厂类
package cn.mldn.oracle.factory;
/**
* 取得DAO接口的工厂类
* @author mldn
*/
public class DAOFactory {
private DAOFactory() {} ; // 为了不产生实例化对象
/**
* 定义DAO接口的对象取得
* @param cls 子类的Class对象
* @return 一个接口的实例化对象
*/
public static <T> T getInstance(Class<T> cls) {
try {
return cls.newInstance() ;
} catch (Exception e) {
e.printStackTrace();
}
return null ;
}
}
业务层接口实现功能
package cn.mldn.oracle.service;
import java.util.List;
import java.util.Map;
import java.util.Set;
import cn.mldn.oracle.vo.Member;
public interface IMemberService {
/**
* 实现用户数据的追加操作处理，本操作要执行如下功能：<br>
* <li>1、使用IMemberDAO.findById()方法判断要增加的用户信息是否存在。</li>
* <li>2、使用IMemberDAO.findByPhone()方法判断要增加的用户电话是否存在。</li>
* <li>3、判断年龄是否大于0，如果不大于0，设置为-1</li>
* <li>4、使用IMemberDAO.doCreate()保存数据</li>
* @param vo 要追加的VO对象
* @return 增加成功返回true，否则返回false
* @throws Exception
*/
public boolean add(Member vo) throws Exception ;
/**
* 进行用户数据的更新处理，此时需要执行如下操作：<br>
* <li>1、使用IMemberDAO.findByPhone()判断修改后的电话是否已经存在（不包含自己的）</li>
* <li>2、判断年龄是否大于0，如果不大于0，设置为-1</li>
* <li>3、调用IMemberDAO.doUpdate()方法进行修改</li>
* @param vo 包含要更新的用户数据
* @return 更新成功返回true，否则返回false
* @throws Exception
*/
public boolean edit(Member vo) throws Exception ;
/**
* 进行用户数据的删除处理，本操作需要经过如下处理：<br>
* <li>1、判断集合之中是否有数据。</li>
* <li>2、调用IMemberDAO.doRemoveBatch()方法删除数据。</li>
* @param ids 包含所有要删除的数据
* @return 如果集合为空（或者集合之中没有数据），以及删除失败返回都是false，否则返回true
* @throws Exception
*/
public boolean remove(Set<String> ids) throws Exception ;
/**
* 根据用户编号查询用户信息，调用IMemberDAO.findById()操作
* @param id 要查询的用户编号
* @return 如果编号存在以VO对象返回，否则返回null
* @throws Exception
*/
public Member get(String id) throws Exception ;
/**
* 调用IMemberDAO.findAll()查询全部数据
* @return 所有的数据以List集合返回，如果没有数据则集合长度为0
* @throws Exception
*/
public List<Member> list() throws Exception ;
/**
* 数据的分页列表显示，要执行如下操作：<br>
* <li>1、调用IMemberDAO.findAllSplit()方法，取得全部的数据。</li>
* <li>2、调用IMemberDAO.getAllCount()方法，统计数据量</li>
* @param currentPage 当前所在页
* @param lineSize 每页显示的数据量
* @return 本次的操作会返回多个结果，以Map的形式保存，包括如下内容：<br>
* <li>key = allMembers、value = IMemberDAO.findAllSplit()，类型：List<Member>、</li>
* <li>key = memberCount、value = IMemberDAO.getAllCount()，类型：Long</li>
* @throws Exception
*/
public Map<String,Object> list(int currentPage,int lineSize) throws Exception ;
/**
* 数据的分页列表显示，要执行如下操作：<br>
* <li>1、调用IMemberDAO.findAllSplit()方法，取得全部的数据。</li>
* <li>2、调用IMemberDAO.getAllCount()方法，统计数据量</li>
* @param column 模糊查询的数据列
* @param keyWord 模糊查询关键字
* @param currentPage 当前所在页
* @param lineSize 每页显示的数据量
* @return 本次的操作会返回多个结果，以Map的形式保存，包括如下内容：<br>
* <li>key = allMembers、value = IMemberDAO.findAllSplit()，类型：List<Member>、</li>
* <li>key = memberCount、value = IMemberDAO.getAllCount()，类型：Long</li>
* @throws Exception
*/
public Map<String, Object> list(String column, String keyWord, int currentPage, int lineSize) throws Exception;
}
业务层接口具体实现类
package cn.mldn.oracle.service.impl;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import cn.mldn.oracle.dao.IMemberDAO;
import cn.mldn.oracle.dao.impl.MemberDAOImpl;
import cn.mldn.oracle.factory.DAOFactory;
import cn.mldn.oracle.service.IMemberService;
import cn.mldn.oracle.vo.Member;
public class MemberServiceImpl implements IMemberService {
@Override
public boolean add(Member vo) throws Exception {
// 1、取得IMemberDAO接口对象
IMemberDAO dao = DAOFactory.getInstance(MemberDAOImpl.class);
if (dao.findById(vo.getMid()) == null) {// 2、判断当前的id是否存在
if (dao.findByPhone(vo.getPhone()) == null) { // 3、电话不存在
if (vo.getAge() <= 0) { // 没有设置年龄或者设置出错
vo.setAge(-1); // 使用-1作为一个标志结果
}
return dao.doCreate(vo); // 4、进行数据库保存
}
}
return false;
}
@Override
public boolean edit(Member vo) throws Exception {
IMemberDAO dao = DAOFactory.getInstance(MemberDAOImpl.class);
// 2、要根据电话来查找数据是否已经存在，但是需要考虑到判断的用户不能是自己
Member temp = dao.findByPhone(vo.getPhone());
if (temp == null) {
return dao.doUpdate(vo);
} else { // 现在电话存在
if (vo.getMid().equals(temp.getMid())) { // 自己的电话
return dao.doUpdate(vo);
}
}
return false;
}
@Override
public boolean remove(Set<String> ids) throws Exception {
if (ids == null || ids.size() == 0) {
return false;
}
return DAOFactory.getInstance(MemberDAOImpl.class).doRemoveBatch(ids);
}
@Override
public Member get(String id) throws Exception {
return DAOFactory.getInstance(MemberDAOImpl.class).findById(id);
}
@Override
public List<Member> list() throws Exception {
return DAOFactory.getInstance(MemberDAOImpl.class).findAll();
}
@Override
public Map<String, Object> list(int currentPage, int lineSize) throws Exception {
Map<String, Object> map = new HashMap<String, Object>();
IMemberDAO dao = DAOFactory.getInstance(MemberDAOImpl.class);
map.put("allMembers", dao.findAllSplit(currentPage, lineSize));
map.put("memberCount", dao.getAllCount());
return map;
}
@Override
public Map<String, Object> list(String column, String keyWord, int currentPage, int lineSize) throws Exception {
Map<String, Object> map = new HashMap<String, Object>();
IMemberDAO dao = DAOFactory.getInstance(MemberDAOImpl.class);
if (column == null || keyWord == null || "".equals(keyWord)) {
map.put("allMembers", dao.findAllSplit(currentPage, lineSize));
map.put("memberCount", dao.getAllCount());
} else {
map.put("allMembers", dao.findAllSplit(column, keyWord, currentPage, lineSize));
map.put("memberCount", dao.getAllCount(column, keyWord));
}
return map;
}
}
业务层动态代理模式
package cn.mldn.oracle.service.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import cn.mldn.oracle.dbc.DatabaseConnection;
public class ServiceProxy implements InvocationHandler {
private Object target ; // 需要有一个真实的操作类对象
@SuppressWarnings("unchecked")
public <T> T bind(Class<T> cls) {
try {
this.target = cls.newInstance();
return (T) Proxy.newProxyInstance(this.target.getClass().getClassLoader(),
this.target.getClass().getInterfaces(), this);
} catch (Exception e) {
e.printStackTrace();
}
return null ;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
Object ret = null ;
String methodName = method.getName() ; // 取得方法名称
if (methodName.startsWith("add") ||
methodName.startsWith("edit") ||
methodName.startsWith("remove")) {
try {
DatabaseConnection.getConnection().setAutoCommit(false);
ret = method.invoke(this.target, args) ;
DatabaseConnection.getConnection().commit();
} catch (Exception e) {
DatabaseConnection.getConnection().rollback();
}
} else {
ret = method.invoke(this.target, args) ;
}
return ret ;
} catch (Exception e) {
throw e ;
} finally {
DatabaseConnection.close();
}
}
}
业务层工厂模式实现
package cn.mldn.oracle.factory;
import cn.mldn.oracle.service.proxy.ServiceProxy;
public class ServiceFactory {
private ServiceFactory() {}
public static <T> T getInstance(Class<T> cls) {
try {
return new ServiceProxy().bind(cls) ;
} catch (Exception e) {
e.printStackTrace();
}
return null ;
}
}
扫一扫
789
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
