entity:
package cn.epet.entity;
/**
* 主人类
*
* @author chaoyi
* @2013-11-7
*/
public class PetOwner {
private int id; // 主人id
private String name; // 姓名
private String password; // 密码
private double money; // 元宝
/**
* 获取主人id
*
* @return 主人id
*/
public int getId() {
return id;
}
/**
* 指定主人id
*
* @param id
* 主人id
*/
public void setId(int id) {
this.id = id;
}
/**
* 获取姓名
*
* @return 姓名
*/
public String getName() {
return name;
}
/**
* 指定姓名
*
* @param name
* 姓名
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取密码
*
* @return 密码
*/
public String getPassword() {
return password;
}
/**
* 指定密码
*
* @param password
* 密码
*/
public void setPassword(String password) {
this.password = password;
}
/**
* 获取元宝
*
* @return 元宝
*/
public double getMoney() {
return money;
}
/**
* 指定元宝
*
* @param money
* 元宝
*/
public void setMoney(double money) {
this.money = money;
}
/**
* 无参构造方法
*/
public PetOwner() {
}
/**
* 有参构造方法
*
* @param id
* 主人id
* @param name
* 姓名
* @param password
* 密码
* @param money
* 元宝
*/
public PetOwner(int id, String name, String password, double money) {
this.setId(id);
this.setName(name);
this.setPassword(password);
this.setMoney(money);
}
}
/**
*
*/
package cn.epet.entity;
import java.util.Date;
/**
* @author 北大青鸟 宠物实体类
*
*/
public class Pet {
/**
* 宠物标识符
*/
private long id;
/**
* 宠物名称
*/
private String name;
/**
* 宠物类别
*/
private String typeName;
/**
* 宠物健康指数
*/
private int health;
/**
* 宠物爱心
*/
private int love;
/**
* 宠物生日
*/
private Date birthdate;
/**
* 宠物所属宠物主人标识符
*/
private int ownerId;
/**
* 宠物所属宠物商店标识符
*/
private long storeId;
/**
* 获取宠物所属宠物主人标识符
*
* @return the ownerId
*/
public int getOwnerId() {
return ownerId;
}
/**
* 指定宠物所属宠物主人标识符
*
* @param ownerId
* the ownerId to set
*/
public void setOwnerId(int ownerId) {
this.ownerId = ownerId;
}
/**
* 获取宠物生日
*
* @return the birthdate
*/
public Date getBirthdate() {
return birthdate;
}
/**
* 获取宠物所属宠物商店标识符
*
* @return the storeId
*/
public long getStoreId() {
return storeId;
}
/**
* 指定宠物所属宠物商店标识符
*
* @param storeId
* the storeId to set
*/
public void setStoreId(long storeId) {
this.storeId = storeId;
}
/**
* 指定宠物生日
*
* @param birthdate
* the birthdate to set
*/
public void setBirthdate(Date birthdate) {
this.birthdate = birthdate;
}
/**
* 获取健康值
*
* @return the health
*/
public int getHealth() {
return health;
}
/**
* 指定健康值
*
* @param health
* the health to set
*/
public void setHealth(int health) {
this.health = health;
}
/**
* 获致宠物标识符
*
* @return the id
*/
public long getId() {
return id;
}
/**
* 指定宠物标识符
*
* @param id
* the id to set
*/
public void setId(long id) {
this.id = id;
}
/**
* 获取亲密度
*
* @return the love
*/
public int getLove() {
return love;
}
/**
* 指定亲密度
*
* @param love
* the love to set
*/
public void setLove(int love) {
this.love = love;
}
/**
* 获取昵称
*
* @return the name
*/
public String getName() {
return name;
}
/**
* 指定昵称
*
* @param name
* the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取类型名
*
* @return the typeName
*/
public String getTypeName() {
return typeName;
}
/**
* 指定类型名
*
* @param typeName
* the typeName to set
*/
public void setTypeName(String typeName) {
this.typeName = typeName;
}
}
dao：
package cn.epet.dao;
import java.util.List;
import cn.epet.entity.PetOwner;
/**
* 主人数据访问层接口
*
* @author chaoyi
* @2013-11-7
*/
public interface PetOwnerDao {
/**
* 对PetOwner进行查询操作
*
* @param sql
* @param pars
* @return list<PetOwner>
*/
List<PetOwner> executeQuery(String sql, Object[] pars);
/**
* 对PetOwner进行增、删、改操作
*
* @param sql
* @param pars
* @return int
*/
int executeUpdate(String sql, Object[] pars);
}
package cn.epet.dao;
import java.util.List;
import cn.epet.entity.Pet;
/**
* 主人数据访问层接口
*
* @author chaoyi
* @2013-11-7
*/
public interface PetDao {
/**
* 对PetOwner进行查询操作
*
* @param sql
* @param pars
* @return list<PetOwner>
*/
List<Pet> executeQuery(String sql, Object[] pars);
/**
* 对PetOwner进行增、删、改操作
*
* @param sql
* @param pars
* @return int
*/
int executeUpdate(String sql, Object[] pars);
}
package cn.epet.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* 数据连接与关闭工具类
*
* @author chaoyi
* @2013-11-7
*/
public class BaseDao {
// 数据库驱动字符串
private static String driver = "oracle.jdbc.driver.OracleDriver";
// 连接URL字符串
private static String url = "jdbc:oracle:thin:@localhost:1521:oracle10";
// 数据库用户名
private static String user = "epet";
// 用户密码
private static String password = "accp";
/**
* 获取数据库连接对象
*
* @return 连接对象
*/
public Connection getConnection() {
Connection conn = null; // 数据连接对象
// 获取连接并捕获异常
try {
Class.forName(driver);
conn = DriverManager.getConnection(url, user, password);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
return conn; // 返回连接对象
}
/**
* 关闭数据库连接
*
* @param conn
* 数据库连接
* @param pstmt
* PreparedStatement对象
* @param rs
* 结果集
*/
public void closAll(Connection conn, PreparedStatement pstmt, ResultSet rs) {
// 若结果集对象不为空，则关闭
if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
// 若PreparedStatement对象不为空，则关闭
if (pstmt != null) {
try {
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
// 若数据库连接对象不为空，则关闭
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/**
* 执行更新、删除、插入SQL语句命令
*
* @param sql
* @param pars
* @return int
*/
public int executeUpdate(String sql, Object[] pars) {
int rowCount = 0;
Connection conn = null;
PreparedStatement pstmt = null;
try {
// 连接数据库
conn = this.getConnection();
// 创建数据库命令对象
pstmt = conn.prepareStatement(sql);
if (pars != null) {
for (int i = 0; i < pars.length; i++) {
pstmt.setObject(i + 1, pars[i]);
}
}
// 执行数据库命令
rowCount = pstmt.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
}
return rowCount;
}
}
实现dao：
package cn.epet.dao.impl;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import cn.epet.dao.BaseDao;
import cn.epet.dao.PetDao;
import cn.epet.entity.Pet;
/**
* PetOwnerDaoImpl类继承数据库连接，实现数据访问层接口
*
* @author chaoyi
* @2013-11-7
*/
public class PetDaoImpl extends BaseDao implements PetDao {
/**
* 对Pet查询操作
*/
public List<Pet> executeQuery(String sql, Object[] pars) {
// 创建ArrayList集合对象并把Pet查询信息放入其中
List<Pet> list = new ArrayList<Pet>();
Connection conn = null; // 数据连接对象
PreparedStatement pstmt = null; // PreparedStatement对象
ResultSet rs = null; // 结果集对象
try {
// 获取数据连接对象
conn = super.getConnection();
// 创建数据库命令对象
pstmt = conn.prepareStatement(sql);
if (pars != null) {
for (int i = 0; i < pars.length; i++) {
pstmt.setObject(i + 1, pars[i]);
}
}
// 执行数据库命令
rs = pstmt.executeQuery();
// 处理结果
while (rs.next()) {
// 创建一个宠物对象
Pet pet = new Pet();
pet.setId(rs.getInt(1));
pet.setName(rs.getString(2));
pet.setTypeName(rs.getString(3));
pet.setHealth(rs.getInt(4));
pet.setLove(rs.getInt(5));
pet.setBirthdate(rs.getDate(6));
pet.setOwnerId(rs.getInt(7));
pet.setStoreId(rs.getLong(8));
list.add(pet);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
// 调用关闭数据库连接
super.closAll(conn, pstmt, rs);
}
return list;
}
}
package cn.epet.dao.impl;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import cn.epet.dao.BaseDao;
import cn.epet.dao.PetOwnerDao;
import cn.epet.entity.PetOwner;
/**
* PetOwnerDaoImpl类继承数据库连接，实现数据访问层接口
*
* @author chaoyi
* @2013-11-7
*/
public class PetOwnerDaoImpl extends BaseDao implements PetOwnerDao {
/**
* 对PetOwner查询操作
*/
public List<PetOwner> executeQuery(String sql, Object[] pars) {
// 创建ArrayList集合对象并把PetOwner查询信息放入其中
List<PetOwner> list = new ArrayList<PetOwner>();
Connection conn = null; // 数据连接对象
PreparedStatement pstmt = null; // PreparedStatement对象
ResultSet rs = null; // 结果集对象
try {
// 获取数据连接对象
conn = super.getConnection();
// 创建数据库命令对象
pstmt = conn.prepareStatement(sql);
if (pars != null) {
for (int i = 0; i < pars.length; i++) {
pstmt.setObject(i + 1, pars[i]);
}
}
// 执行数据库命令
rs = pstmt.executeQuery();
// 处理结果
while (rs.next()) {
// 创建一个主人对象
PetOwner owner = new PetOwner();
owner.setId(rs.getInt(1));
owner.setName(rs.getString(2));
owner.setPassword(rs.getString(3));
owner.setMoney(rs.getDouble(4));
list.add(owner);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
// 调用关闭数据库连接
super.closAll(conn, pstmt, rs);
}
return list;
}
}
biz：
package cn.epet.biz;
import cn.epet.entity.PetOwner;
/**
* 主人业务层接口
*
* @author chaoyi
* @2013-11-8
*/
public interface PetOwnerBiz {
/**
* 实现登录方法
*
* @param owner
* @return 返回登录成功结果
*/
PetOwner login(PetOwner owner);
}
package cn.epet.biz;
import cn.epet.entity.Pet;
/**
* 主人业务层接口
*
* @author chaoyi
* @2013-11-8
*/
public interface PetBiz {
/**
* 添加宠物信息
*
* @param pet
* @return int
*/
int addPetInfo(Pet pet);
}
实现biz:
package cn.epet.biz.impl;
import java.text.SimpleDateFormat;
import java.util.Date;
import cn.epet.biz.PetBiz;
import cn.epet.dao.PetDao;
import cn.epet.dao.impl.PetDaoImpl;
import cn.epet.entity.Pet;
/**
* PetBizImpl类实现宠物业务层接口
*
* @author chaoyi
* @2013-11-8
*/
public class PetBizImpl implements PetBiz {
/**
* 添加宠物信息
*/
public int addPetInfo(Pet pet) {
// 创建一个PetDaoImpl对象
PetDao petDao = new PetDaoImpl();
// 操作数据字符串
String sql = "insert into pet (ID, NAME, TYPENAME, HEALTH, LOVE, BIRTHDAY, OWNER_ID, STORE_ID)"
+ "values (PET_SEQUENCE.nextval, ?, ?, ?, ?, to_date(?, 'yyyy-mm-dd'), ?, 1)";
Object[] pars = { pet.getName(), pet.getTypeName(), pet.getHealth(),
pet.getLove(),
new SimpleDateFormat("yyyy-MM-dd").format(new Date()),
pet.getOwnerId() };
// 返回增加结果
return petDao.executeUpdate(sql, pars);
}
}
package cn.epet.biz.impl;
import java.util.List;
import cn.epet.biz.PetOwnerBiz;
import cn.epet.dao.PetOwnerDao;
import cn.epet.dao.impl.PetOwnerDaoImpl;
import cn.epet.entity.PetOwner;
/**
* PetOwnerBizImpl类实现主人业务层接口
*
* @author chaoyi
* @2013-11-8
*/
public class PetOwnerBizImpl implements PetOwnerBiz {
/**
* 实现登录方法
*/
public PetOwner login(PetOwner owner) {
// 创建一个PetOwnerDaoImpl对象
PetOwnerDao ownerDao = new PetOwnerDaoImpl();
// 操作数据字符串
String sql = "select * from petowner where name=? and password=?";
// 创建一个对象数组
Object[] pars = { owner.getName(), owner.getPassword() };
// 调用进行查询操作
List<PetOwner> list = ownerDao.executeQuery(sql, pars);
// 判断集合中是否有数据
if (list.size() == 1)
// 返回集合中的第一个对象
return list.get(0);
return null;
}
}
test:
package cn.epet.test;
import java.util.Scanner;
import cn.epet.biz.PetBiz;
import cn.epet.biz.PetOwnerBiz;
import cn.epet.biz.impl.PetBizImpl;
import cn.epet.biz.impl.PetOwnerBizImpl;
import cn.epet.entity.Pet;
import cn.epet.entity.PetOwner;
/**
* PetOwner测试类
*
* @author chaoyi
* @2013-11-8
*/
public class PetOwnerTest {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
// 创建一个主人对象
PetOwner owner = new PetOwner();
// 接收用户输入登录的信息
System.out.println("*****欢迎光临宠物乐园*****");
System.out.print("请输入登录名：");
owner.setName(input.next());
System.out.print("请输入密码：");
owner.setPassword(input.next());
// 创建一个PetOwnerBizImpl对象
PetOwnerBiz biz = new PetOwnerBizImpl();
// 接收实现登录方法
PetOwner login = biz.login(owner);
// 判断是否登录成功
if (login != null) {
// 创建一个宠物对象
Pet pet = new Pet();
// 实现领养宠物
System.out.println("登录成功！用户ID号是：" + login.getId());
System.out.print("\n请输入领养宠物的名称:");
pet.setName(input.next());
System.out.print("请输入领养宠物的类型:");
pet.setTypeName(input.next());
pet.setHealth(1);
pet.setLove(1);
pet.setOwnerId(login.getId());
// 创建一个PetBizImpl对象
PetBiz petBiz = new PetBizImpl();
// 判断是否领养成功
if (petBiz.addPetInfo(pet) > 0) {
System.out.println("领养成功！");
} else
System.out.println("领养失败！");
} else
System.out.println("用户名或密码错误，登录失败！");
}
}
效果图：
个人E-mail：chaoyi77@163.com
相关推荐
根据提供的文件信息，我们可以深入探讨如何使用 Codesmith 来生成三层架构中的数据访问层（DAL）。三层架构是一种常见的软件架构模式，它将应用程序分为三个主要的逻辑层：表示层、业务逻辑层和数据访问层。这种分层...
数据访问层（Data Access Layer，DAL）是软件架构中的一个重要组成部分，主要负责处理应用程序与数据库之间的交互。在.NET环境中，创建高效、可复用的数据访问层对于任何项目都是至关重要的。"最好的数据访问层源码...
数据访问层（DAL）是软件开发中的一个重要组成部分，主要用于处理应用程序与数据库之间的交互。本说明书旨在详细阐述数据访问层的设计背景、目标、技术架构、实现方法以及相关规则，以指导开发人员规范地进行数据库...
8. 数据访问层优化 数据访问层优化是 MySQL 优化的重要步骤。通过优化数据访问层，可以提高数据的访问速度和效率。例如，可以使用 Connection Pool 机制来提高数据的并发访问能力，从而提高数据的访问速度和效率。 ...
Java数据访问层（Data Access Layer，DAL）是应用程序中负责处理与数据库交互的部分，它封装了数据库操作，使得业务逻辑层可以专注于业务处理，而无需关心底层数据存储的细节。在Java开发中，DBTools是一个常见的...
8. 数据访问层、数据持久层、表示层、控制层和业务逻辑层等网络架构设计 9. JavaWeb开发技术的应用 10. 研究生培养质量管理中的问题分析和解决 11. 地方高校研究生培养质量管理的挑战和机遇 12. JavaEE平台的优势和...
8. 数据访问层（DAL）：DAL负责与数据库进行交互，通常使用ADO.NET来执行SQL语句，如查询、插入、更新和删除数据。它可以封装成接口或类库，供其他层调用。 9. 销售流程管理：网上鲜花销售系统需要实现完整的购物...
在Java开发中，数据访问层（Data Access Layer, DAL）是应用程序的重要组成部分，负责与数据库进行交互，执行CRUD（创建、读取、更新、删除）操作。减少数据访问层的代码可以提高代码的可维护性、可读性和效率。以下...
8. 数据访问层：此层封装了与数据库的交互，通过ADO.NET的SqlCommand对象执行SQL语句，实现数据的CRUD操作。使用数据访问层可以降低业务逻辑层和数据层的耦合度，提高代码的可维护性。 9. 错误处理与日志记录：为了...
数据库访问层（Database ...通过深入理解这些概念，开发者能够构建出健壮的数据访问层，满足各种应用程序的需求。在实际项目中，DBAccess可能是一个包含多个类和接口的模块，它们共同协作，构成了数据库操作的核心。
数据链路层在OSI/RM模型和TCP/IP模型中被分为两部分：逻辑链路控制（LLC）子层和介质访问控制（MAC）子层。LLC子层主要负责逻辑链路的建立、维护和释放，以及数据流量控制和错误处理。MAC子层则专注于控制不同用户对...
8. 数据访问层： DAL是与数据库交互的组件，可能使用ADO.NET或Entity Framework等技术，封装SQL查询，提供简单的接口供BLL调用，以完成数据的增删改查操作。 9. 错误处理与日志记录： 系统应包含适当的错误处理...
8. 数据访问层（DAL）和业务逻辑层（BLL）：为了实现代码复用和模块化，系统可能采用了分层架构，包括数据访问层负责与数据库交互，业务逻辑层处理业务规则，而表示层（ASP.NET页面）则调用BLL完成用户请求。...
8. 数据访问层： 这一层负责与数据库的交互，通过ADO.NET的SqlCommand对象执行SQL语句，获取或更新数据。此外，可以使用存储过程提高性能和安全性。 9. 错误处理和日志记录： 系统应包含错误处理机制，如try-...
8. 错误处理和异常捕获：数据库访问层应包含适当的错误处理和异常捕获机制，以确保在数据访问出现问题时，能够适当地通知用户或记录错误日志。 9. 数据安全：确保数据库访问层的代码符合安全最佳实践，包括参数化...
8. **数据访问层设计模式**：常见的设计模式有工厂模式（用于创建数据库连接和命令对象）、单例模式（限制数据库连接的数量）和仓储模式（将数据操作抽象为接口，便于替换数据访问技术）。 9. **ORM框架**：虽然...
8. **网络地址转换（NAT）**：NAT技术允许局域网内的私有IP地址通过公网IP地址访问互联网。私有IP地址仅在内部网络中有效，而公网IP地址是全球唯一的。NAT转换使得有限的公网IP地址可以供众多内网设备共享，同时保护...
在Java开发中，数据访问层（Data Access Layer，DAL）是应用程序的重要组成部分，它负责处理与数据库的交互，包括查询、插入、更新和删除数据。为了实现这些功能，开发人员通常会利用各种数据访问框架，如MyBatis、...
9. 用户访问层：为IT人员、内部用户和外部用户提供不同权限的访问，满足不同业务场景的需求。 【大数据分析平台演进路线】 平台的演进通常分为多个阶段，初期可能侧重于基础数据平台和BI应用的建设，实现数据的...