一、梳理
1.1、Java面向对象的五大基本原则
单一职责原则：一个类只描述一件事情。
开闭原则：对扩展开发，对修改封闭。
里氏替换原则：子类必须能够替换其他基类（即：任何基类可以出现的地方，子类也一定可以出现）。
依赖倒置原则：依赖于抽象接口，不要依赖于具体实现(即：要求对抽象进行编程，不对实现进行编程，以降低客户与实现模块之间的耦合) 。
接口隔离原则：使用多个小的专用接口，而不是使用一个大接口
1.2、Javabean
必须有一个无参构造方法（无参构造方法也叫无参构造器/无参构造函数）
所有属性必须私有化 private
必须提供公开的getter和setter方法
1.3、实体类注意事项
实体类的名字尽量和数据库的表的名字对应相同。
实体类应该实现java.io.Serializable接口。
实体类应该有个无参的构造方法。
实体类应该有个有参（所有的参数）的构造方法。
实体类有属性和方法，属性对应数据库中表的字段，方法主要有getter和setter方法。
实体类还应该有个属性serialVersionUID。例如：private static final long serialVersionUID = -6125297654796395674L;
属性一般是private类型，方法为public类型，对于数据库自动生成的ID字段对应的属性的set方法为private。
1.4、自定义类
1.4.1、格式
Class 类名{
事物的公共属性 成员变量描述
事物的公共行为 函数描述
}
1.4.2、通过自定义创建对象
类名 变量名 = new 类名():
1.4.3、访问（设置）对象的属性或者对象的功能
访问对象的属性：对象.属性名
设置对象的属性：对象.属性 = 数据 调用对象的功能： 对象.函数名();
1.5、面向对象的三大特征
继承 关键字 extends 类与类之间关系的一种描述 Java只支持但继承(一个类只有一个直接父类但可以有很多间接父类)，但支持多实现
多态：
封装：把对象的行为和属性定义在一个类中叫封装，类是封装对象和行为的载体
1.6、局部变量与成员变量定义
1.6.1、位置上的区别
成员变量是定义在方法之外，类之内的
局部变量是定义在方法之内的
1.6.2、作用上的区别
成员变量的作用是描述一类事物的公共属性
局部变量的作用是提供一个变量给方法内部使用
1.6.3、生命周期的区别
成员变量是默认的初始值
数据类型 默认初始值
Boolean False Char‘\000’(空字符)
Byte 0(byte)
Short 0(Short)
Int 0
Long 0L
Float 0.0f
Double 0.0
局部变量是没有默认的初始值的，必须要先初始化才能使用。
1.7、构造函数
1.7.1、作用
给对应的对象进行初始化
1.7.2、构造函数的格式
修饰符 函数名(形式参数){
函数体
}
1.7.3、构造函数的说明
构造函数 是没有返回值类型的
构造函数的函数名必须与类名相同
构造函数不是由手动调用，在创建对象是时jvm主动调用构造函数
如果一个类没有显示的写上一个构造方法时，java编译器会为该类添加一个无参构造函数
如果一个类显示的写上了一个构造方法，那么Java编译器则不会为该类添加一个无参的构造函数
构造函数可以在一个类中以函数重载的形式存在多个
1.8、JDK提供一个Java开发工具（java.exe）给我们进行反编译
1.8.1、 javap 反编译的使用格式
javap -c -1 -private 类名
1.8.2、Java编译器添加的无参构造函数的权限修饰符 是什么
与类的权限修饰符是一致的。
1.9、构造函数与普通函数的区别
1.9.1、返回值类型
构造函数没有返回值类型
普通函数是有返回值类型的，即使函数没有返回值，返回值类型也要写上void
1.9.1、 函数名
构造函数的函数名必须与类名相同
普通函数只要符合标识符的命名规则即可
1.9.2、调用方式
构造函数是在创建对象的时候由JVM调用
普通函数是由我们使用对象调用的，一个对象可以调用多次普通函数
1.9.3、作用不同
构造函数的作用是初始化一个对象
普通函数是用于描述一类公共事物的行为
1.10、this关键字与super关键字
this关键字
this关键字代表了所属函数的调用者对象 谁调用我 我就调用谁 this.qq =qq; 初始化成员变量
this关键字的作用
如果存在同名成员变量与局部变量，在方法内部默认是访问局部变量的数据，可以通过this关键字指定访问成员变量的数据。
在一个构造函数中可以调用另外一个构造函数初始化对象
this关键字调用其他构造函数的注意事项：
this关键字调用其他构造函数，this关键必须要位于构造函数的第一个语句
this关键字在构造函数中不能出现相互调用的情况，这是一个死循环
this关键字要注意的事项：
存在同名成员变量与局部变量时，在方法内部访问的事局部变量（java 采用的是”就近原则“ 访问的）
如果在一个方法中访问了一个变量，该变量只存在成员变量的情况下，那么java编译器会在该变量的 前面添加this关键字。
super()
指向父类引用空间
引用父类的成员属性
引用父类的成员方法
访问控制权限
同类 同包 子父类 不同包
public(公共的) true true true true
protected（受保护的） true true true false
default（默认的） true true false false
private （私有） true false false false
在不同包中public与protected可以访问，而private必须存在继承关系才能访问
枚举
概念
枚举类型继承于java.lang.Enum类，用户可以把它看成一个类
当定义一个枚举类型时，每一个枚举类型成员都可以看成一个枚举类型的实例
枚举类型默认都被final,public,static修饰
关键字enum
优势
类型安全
紧凑有效的数据定义
可以和程序其他部分完美交互
运行效率高
使用枚举类型成员时直接使用枚举名称调用枚举类型成员即可
过滤器
概念：普通Java类实现Filter接口 ---- 》过滤器
作用：用户在请求某个目标资源之前对访问请求的拦截
Filter链：一个web项目中有多个filter，这些filter合称filter链
Filter调用顺序
web.xml中注册顺序决定doFilter的调用顺序
第一个filter的doFilter被调用 ----》 web服务器创建代表filter的链filterChain对象的doFilter方法----》 web服务器检查FilterChain对象中是否有filter,有则调用，无则调用目标资源
servlet
概念：Java技术的web组件(第三方)，springMVC,Struts,webWork,siteMesh的框架
普通Java类继承HttpServlet
相关接口
servlet
servletConfig
servletContext
FenericServlet实现servlet接口
servlet生命周期
构造方法 隐式/显示
init方法 创建servlet对象后调用 只调用一次
service方法 每次发送请求时调用 可调用多次
destory方法 调用一次，停止服务时调用
jsp
四个域对象
域名称 域对象 作用范围
page域 response 只能在当前jsp页面中使用（当前页面）
request域 Request 只能在同一个请求中使用（转发）
session域 Session 只能在同一个会话（session对象）中使用（私有的）
context域 application context域： 只能在同一个web应用中使用。（全局的）
九个内置对象
内置对象的名称 内置对象的类型
Request HttpServletRequest
response HttpServletResponse
config ServletCofig
application ServletContext
session HttpSession
exception Throwable
page Object(this)
out JspWriter
pageContext PageContext 上下文对象
内置对象：jsp页面加载完成之后会自动帮开发者创建一些对象，而开发者只需要直接使用这些对象调用方法，这些创建好的对象就叫内置对象
转发与重定向
转发只能转到当前web应用内的资源，转发过程中可以吧数据保存到request域中
重定向可以跳转到当前web应用，其他web应用，甚至外部域名或者网站
使用request对象域进行数据共享只能使用转发技术
二、餐桌模块
2.1、餐桌实体类(JavaBean)
package cn.itcase.entity;
import java.util.Date;
/**
* 餐桌模块实体类 javaBean
*
* @author Administrator
*
*/
public class DinnerTable {
private int id; // 餐桌id 主键 int auto_increment
private String tableName; // 餐桌名称 varchar(20) not null
private int tableStatus; // 餐桌状态 int default
private Date orderDate; // 订单时间 datetime null
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getTableName() {
return tableName;
}
public void setTableName(String tableName) {
this.tableName = tableName;
}
public int getTableStatus() {
return tableStatus;
}
public void setTableStatus(int tableStatus) {
this.tableStatus = tableStatus;
}
public Date getOrderDate() {
return orderDate;
}
public void setOrderDate(Date orderDate) {
this.orderDate = orderDate;
}
// 无参构造器
public DinnerTable(){
}
// 有参构造器
public DinnerTable(int id,String tableName,int tableStatus,Date orderDate){
super();
this.id = id;
this.tableName = tableName;
this.tableStatus = tableStatus;
this.orderDate = orderDate;
}
}2.2、dao接口
package cn.itcase.dao;
import java.util.List;
import cn.itcase.entity.FoodType;
// 菜系模块 dao接口
public interface FoodTypeDao {
void save(FoodType foodType); // 添加
FoodType findByid(int id); // 根据主键查询
void update(FoodType foodType); // 更新
void delete(int id); //删除
List<FoodType> getAll(); //查询全部
List<FoodType> getAll(String foodName); //根据菜系名称查询
}2.3、dao接口实现类
package cn.itcase.dao.impl;
import java.sql.SQLException;
import java.util.Date;
import java.util.List;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import cn.itcase.dao.DinnerTableDao;
import cn.itcase.entity.DinnerTable;
import cn.itcase.utils.JdbcUtils;
/**
* 餐桌模块 接口实现类
*
* @author Administrator
*
*/
public class DinnerTableDaoImp implements DinnerTableDao {
private QueryRunner qr = JdbcUtils.getQueryRunner();
/* 添加数据 */
@Override
public void add(DinnerTable dt) {
String sql = "insert dinnertable(tableName) values(?);";
try {
qr.update(sql, dt.getTableName());
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
/* 根据id删除信息 */
@Override
public void delete(int id) {
String sql = "delect from dinnertable where id =?;";
try {
qr.update(sql, id);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
/* 修改数据 */
@Override
public void updata(DinnerTable dt) {
String sql = "update dinnertable set tableStatus=?,orderDate=? WHERE id=?;";
Date date = dt.getOrderDate();
try {
JdbcUtils.getQueryRunner().update(sql, dt.getTableStatus(), date,
dt.getId());
} catch (SQLException e) {
e.printStackTrace();
}
}
/*关键字查询*/
@Override
public List<DinnerTable> query() {
String sql = "select * from DinnerTable;";
try {
return qr.query(sql, new BeanListHandler<DinnerTable>(
DinnerTable.class));
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
/* 根据id查询所有数据 */
@Override
public DinnerTable findByid(int id) {
try {
String sql = "select * from dinnertable where id = ?";
return qr.query(sql,
new BeanHandler<DinnerTable>(DinnerTable.class));
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
/* 查詢餐桌模块的所有信息 */
@Override
public List<DinnerTable> query(String keyWord) {
String sql = "select * from dinnertable where tableName LIKE ?";
try {
return qr.query(sql, new BeanListHandler<DinnerTable>(
DinnerTable.class), "%" + keyWord + "%");
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
/* 根据id修改 餐桌状态 時間 */
@Override
public void quitTable(int id) {
String sql = "update dinnerTable set tableStatus=?,orderDate=? where id= ? ;";
try {
JdbcUtils.getQueryRunner().update(sql, null, id);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}2.4、service接口
package cn.itcase.service;
import java.util.List;
import cn.itcase.entity.DinnerTable;
/**
* 餐桌模块 业务逻辑层接口
* */
public interface DinnerTableService {
public void add(DinnerTable dt); // 添加
public void delete(int id); // 根据id删除
public void updata(DinnerTable dt); // 更新
public List<DinnerTable> query(); // 查询
public DinnerTable findByid(int id);// 根据id查询所有信息
public List<DinnerTable> query(String keyWord); // 根据关键字查询(模糊查詢)
public void quitTable(int id); // 根据修改数据
public DinnerTable exchange(int id); //餐桌状态
}2.5、service接口实现类
package cn.itcase.service.impl;
import java.util.Date;
import java.util.List;
import cn.itcase.dao.DinnerTableDao;
import cn.itcase.entity.DinnerTable;
import cn.itcase.factory.BeanFactory;
import cn.itcase.service.DinnerTableService;
public class DinnerTableServiceImpl implements DinnerTableService {
// 多态使用 松散型耦合
DinnerTableDao dao = BeanFactory.getInstance("dinnerTableDao",
DinnerTableDao.class);
// 接口数据类型 指向 接口实现类 紧密型耦合
// DinnerTableDao dao = new DinnerTableImp();
/**
* 1.添加数据
*/
@Override
public void add(DinnerTable dt) {
// TODO Auto-generated method stub
dao.add(dt);
}
/**
* 2.根据id删除数据
*/
@Override
public void delete(int id) {
// TODO Auto-generated method stub
dao.delete(id);
}
/**
* 3.修改数据
*/
@Override
public void updata(DinnerTable dt) {
// TODO Auto-generated method stub
dao.updata(dt);
}
/**
* 4. 查询数据
*/
@Override
public List<DinnerTable> query() {
// TODO Auto-generated method stub
return dao.query();
}
/**
* 5.根据id查询所有数据
*/
@Override
public DinnerTable findByid(int id) {
// TODO Auto-generated method stub
return dao.findByid(id);
}
/**
* 6.模糊查询
*/
@Override
public List<DinnerTable> query(String keyWord) {
// TODO Auto-generated method stub
return dao.query(keyWord);
}
/**
* 7.根据id修改数据
*/
@Override
public void quitTable(int id) {
// TODO Auto-generated method stub
dao.quitTable(id);
}
/**
* 8、餐桌状态
*/
@Override
public DinnerTable exchange(int id) {
DinnerTable table = dao.findByid(id);
// 餐桌状态 0 或 1
int status = table.getTableStatus();
if (status == 0) { // 未预定 ---》 预定
status = 1;
Date date = new Date();
table.setOrderDate(date);
} else if (status == 1) { // 预定 ----》为预定
status = 0;
table.setOrderDate(null);
}
table.setTableStatus(status);
dao.updata(table);
return table;
}
}2.6、bean工厂
package cn.itcase.factory;
import java.util.ResourceBundle;
/**
* bean工场：创建dao或service实例 实现前后端的分离
* @author Administrator
*
*/
public class BeanFactory {
// 加载配置文件
private static ResourceBundle bundle;
static{
//java.util的内置方法，主要功能是用于解析properties文件 被static修饰的代码块之加载一次
bundle =ResourceBundle.getBundle("instance");
}
/**
* 根据指定给的key，读取配置文件获取文件类的全路径;创建对象
* @return
*/
public static <T> T getInstance(String key,Class<T> clazz){
String className = bundle.getString(key);
try{
/*
* Class.forName()返回要加载的类的class实例
* newInstance()工厂类常用用来创建的对象的方式
*
* 与new关键字创建对象的比较
* newInstance: 弱类型。低效率。只能调用无参构造。
* new: 强类型。相对高效。能调用任何public构造。
*/
return(T) Class.forName(className).newInstance();
}catch(Exception e){
throw new RuntimeException(e);
}
}
}2.6、控制器(servlet)
基类
package cn.itcase.servlet;
import java.io.IOException;
import java.lang.reflect.Method;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import cn.itcase.factory.BeanFactory;
import cn.itcase.service.DinnerTableService;
import cn.itcase.service.FoodService;
import cn.itcase.service.FoodTypeService;
import cn.itcase.service.LoginService;
import cn.itcase.service.OrderDatailService;
import cn.itcase.service.OrderService;
import cn.itcase.utils.WebUtils;
/**
* 项目中所有servlet的基类 基类：继承关系中的"节点"
*
* @author Administrator
*
*/
public abstract class BaseServlet extends HttpServlet {
// 创建service
protected DinnerTableService dinnerTableService = BeanFactory.getInstance(
"dinnerTableService", DinnerTableService.class);
protected FoodService foodService = BeanFactory.getInstance("foodService",
FoodService.class);
protected FoodTypeService foodTypeService = BeanFactory.getInstance(
"foodTypeService", FoodTypeService.class);
protected OrderService orderService = BeanFactory.getInstance(
"orderService", OrderService.class);
protected OrderDatailService orderDatailService = BeanFactory.getInstance(
"orderDatailService", OrderDatailService.class);
protected LoginService loginService = BeanFactory.getInstance(
"loginService", LoginService.class);
@Override
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
// 保存跳转的资源 ---- 方法返回值
Object returnValue = null;
// 获取操作类型：【约定>俗称：操作类型的值，必须对应servlet中的方法名称】
String methodName = request.getParameter("method"); // 根据参数名获取参数值
try {
// 获取当前运行类的字节码
Class clazz = this.getClass();
// 获取当前执行的方法的Method类型
Method method = clazz.getDeclaredMethod(methodName,
HttpServletResponse.class);
// 3. 执行方法
returnValue = method.invoke(this, request, response);
} catch (Exception e) {
e.printStackTrace();
returnValue = "/error/error.jsp";
}
// 跳转
WebUtils.goTo(request, response, returnValue);
}
@Override
protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
this.doGet(request, response);
}
}餐桌模块控制器
package cn.itcase.servlet;
import java.io.IOException;
import java.util.List;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import cn.itcase.entity.DinnerTable;
import cn.itcase.factory.BeanFactory;
import cn.itcase.service.DinnerTableService;
/**
* 餐桌模块控制器
*
* http协议的请求方式
*
* @author Administrator
*
*/
public class DinnerTableServlet extends HttpServlet {
// 版本控制
private static final long serialVersionUID = 1L;
// 多态
private DinnerTableService dTservice = BeanFactory.getInstance(
"dinnerTableService", DinnerTableService.class);
// 隐藏的构造方法 初始化参数
// 创建servlet init
@Override
public void init(ServletConfig config) throws ServletException {
super.init(config); // 引用父类的init方法
List<DinnerTable> list = dTservice.query();
config.getServletContext().setAttribute("table", list);
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String method = request.getParameter("method");
if ("add".equals(method)) {
add(request, response);
} else if ("list".equals(method)) {
list(request, response);
} else if ("up".equals("method")) {
update(request, response);
} else if ("delete".equals(method)) {
delete(request, response);
} else if ("search".equals("method")) {
search(request, response);
}
}
// 搜索
private void search(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String keyword = request.getParameter("keyword");
if (keyword != null) {
List<DinnerTable> list = dTservice.query(keyword);
request.setAttribute("list", list);
request.getRequestDispatcher("/boardList.jsp").forward(request,
response);
}
}
// 删除
private void delete(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String id = request.getParameter("id");
dTservice.delete(Integer.parseInt(id));
list(request, response);
}
// 修改
private void update(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String id = request.getParameter("id");
dTservice.exchange(Integer.parseInt(id));
list(request, response);
}
//页面展示
private void list(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
List<DinnerTable> list = dTservice.query();
request.setAttribute("list", list);
// 将餐桌列表存到context里传到前台显示
request.getServletContext().setAttribute("table", list);
request.getRequestDispatcher("/boardList.jsp").forward(request,
response);
}
// 添加
private void add(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String tableName = request.getParameter("tableName");
if (tableName != null) {
DinnerTable dt = new DinnerTable();
dt.setTableName(tableName);
dTservice.add(dt);
list(request, response);
}
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
2.7、过滤器(filter链)
请求资源浏览器类型过滤
package cn.itcase.filter;
/**
* 浏览器过滤器
*/
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class BrowserFilter implements Filter {
// 创建
@Override
public void init(FilterConfig config) throws ServletException {
}
// 调用doFilter方法 访问web资源，不调用不访问
@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
// 转型
HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse res = (HttpServletResponse) response;
String userAgent = req.getHeader("user-agent"); // 获取请求头
if(userAgent.contains("Firefox")){ // 当前获取web服务器资源的浏览器类型是否为Firefox
chain.doFilter(request, response);
}else if(userAgent.contains("Chrome")){ // 当前获取web服务器资源的浏览器类型是否为Chrome浏览器
chain.doFilter(request, response);
}else if(userAgent.contains("safan")){ // 当前获取web服务器资源的浏览器类型是否为safan浏览器
chain.doFilter(request, response);
}else{ //其他浏览器访问资源
System.out.println("其他浏览器访问资源");
}
}
// 销毁
@Override
public void destroy() {
}
}编码过滤
package cn.itcase.filter;
import java.io.UnsupportedEncodingException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
/**
* 辅助EncodingRequest
* HttpServletRequestWrapper 的实例作用：过滤敏感字眼
*
* @author Administrator
*
*/
public class EncodingRequest extends HttpServletRequestWrapper {
private HttpServletRequest req;
// 有参构造 初始化成员变量
public EncodingRequest(HttpServletRequest request) {
super(request);// 引用父类request成员
this.req = request;
}
// tomcat默认iso-88s9默认编码处理
public String getParameter(String name) {
// 根据参数名获取参数值
String value = req.getParameter(name);
if (value != null) {
try {
value = new String(value.getBytes("iso-8859"), "utf-8");
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e);
}
}
return value;
}
}package cn.itcase.filter;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
/**
* 资源请求方式
* @author Administrator
*
*/
public class EncodingFilter implements Filter {
@Override
public void destroy() {
// TODO Auto-generated method stub
}
@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
// 请求的编码格式
request.setCharacterEncoding("utf-8");
/*
* // 设置响应体的编码格式: response.setCharacterEncoding("utf-8");
*
* // 设置首页打开时候的编码格式: response.setContentType("text/html;charset=UTF-8");
*/
HttpServletRequest req = (HttpServletRequest) request;
if(req.getMethod().equals("GET")) { // get請求
EncodingRequest et = new EncodingRequest(req);
chain.doFilter(et, response);
} else if(req.getMethod().equals("POST")) { // post請求
chain.doFilter(request, response);
}
}
@Override
public void init(FilterConfig arg0) throws ServletException {
// TODO Auto-generated method stub
}
}2.8、工具类(utils)
package cn.itcase.utils;
import javax.sql.DataSource;
import org.apache.commons.dbutils.QueryRunner;
import com.mchange.v2.c3p0.ComboPooledDataSource;
/**
* 封装常用的操作
*
* @author Administrator
*
*/
public class JdbcUtils {
// 初始化连接池 被static修饰的的成员变量为共享数据
private static DataSource dataSource;
static {
dataSource = new ComboPooledDataSource();
}
public static DataSource getDataSource() {
return dataSource;
}
/**
* 创建Dbutils常用工具类
*
*/
public static QueryRunner getQueryRunner() {
/*
* 创建QueryRunner对象，传入连接池对象
* 在创建QueryRunner对象的时候，如果传入了数据源对象；
* 那么在使用QueryRunner对象方法的时候，就不需要传入连接对象；
* 会自动从数据源中获取连接(不用关闭连接)
*/
return new QueryRunner(dataSource);
}
}instance.properties
# dao instance
foodtypeDao=cn.itcase.dao.FoodTypeDao
dinnerTableDao=cn.itcase.dao.dinnerTableDao
foodDao=cn.itcase.dao.FoodDao
orderDao=cn.itcase.dao.OrderDao
orderDatailDao=cn.itcase.dao.OrderDatailDao
login = cn.itcase.dao.LoginDao
# service instance
foodTypeService=cn.itcase.service.FoodTypeService
dinnerTableService=cn.itcase.service.DinnerTableService
foodService=cn.itcase.service.FoodService
orderService=cn.itcase.service.OrderService
orderDatailService=cn.itcase.service.OrderDatailService
login = cn.itcase.dao.LoginDao
2.9、连接池(c3p0)
<c3p0-config>
<default-config>
<!-- 数据库驱动 -->
<property name="driverClass">com.mysql.jdbc.Driver</property>
<!-- 与数据库建立连接 -->
<!--<property name="jdbcUrl">jdbc:mysql:///hotel?useUnicode=true&characterEncoding=utf8</property>-->
<property name="jdbcUrl"><![CDATA[jdbc:mysql://localhost:3306/hotel?useUnicode=true&characterEncoding=utf8]]></property>
<!-- 用户 -->
<property name="user">root</property>
<!-- 密码 -->
<property name="password">0000</property>
<!-- 最小连接数 默认为：3 -->
<property name="initialPoolSize">5</property>
<!-- 最大连接数 默认为15 -->
<property name="maxPoolSize">10</property>
</default-config>
<named-config name="oracleConfig">
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql:///hotel</property>
<property name="user">root</property>
<property name="password">0000</property>
<property name="initialPoolSize">5</property>
<property name="maxPoolSize">10</property>
</named-config>
</c3p0-config>本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
