javaweb

javaweb

JSP:动态网页

在html中嵌套的java代码<% %>)

动态网页：是否随着时间，地点，用户操作的改变而改变

动态网页需要使用到服务端脚本语言（JSP）

BS和CS架构

BS,CS各有优势
CS:Client Server 客户端,服务端 不足:

​ a.如果服务器软件升级，那么全部客户端软件都需要升级

​ b.维护麻烦

​ c.每一个客户端都需要安装客户端软件

BS:Broswer Server浏览器,服务器 客户端可以通过浏览器直接访问服务端(Tomcat服务器)

tomcat

tomcat端口号默认是8080(建议修改(8888))

修改端口号:在conf中修改

tomcat解压后目录:

​ bin:可执行文件(startup.bat shutdown.bat)

​ conf:配置文件(server.xml)

​ lib:tomcat依赖的jar包

​ logs:日志文件(记录出错等信息)

​ temp:临时文件

​ webapps:可执行的项目(将我们开发的项目放到该目录)

​ work:存放由jsp翻译成的Java，以及编译成的class文件

常见状态码:404:资源不存在

​ 200:一切正常

​ 403:权限不足

​ 300/301:页面重定向

​ 500:服务器内部错误

在项目/WEB-INF/web.xml中设置默认的初始页面

   ```java

index.jsp ```

虚拟路径

​ (将web项目配置到webapps文件以外的目录)
​ 1.在conf/server.xml中的host标签中配置
​ <Context docBase=“绝对路径” path=“相对路径”[相对于webapps] />
​ (需要重启tomcat服务器)
2.在conf\Catalina\localhost中新建一个 (项目名).xml 中新增一行
​ <Context docBase=“绝对路径” path=“相对路径”[相对于webapps] />

虚拟主机

JSP执行流程

jsp->java(servlet文件)->class

使用Eclipse快速开发web项目(JSP项目)

！！一般而言：修改web.xml,配置文件,java需要重新启动tomcat服务器；但是修改jsp,css,html,js文件不需要重启tomcat服务器

在eclipse中创建的web项目:
浏览器可以直接访问WebContent中的文件，但是WEB-INF中的文件无法通过客户端直接访问， 只能通过请求转发来访问
(跳转有两种方式，一种是请求转发，另一种是重定向)

配置tomcat运行时的环境

第一种方法；将tomcat/lib/servlet-api.jar加入项目的构建路径中
第二种方法：右键项目->Build Path->Add library->server Runtime

JSp的页面元素(html,java代码(脚本),注释,指令)

脚本Scriptlet(三种形式)

<%      java代码(局部变量，Java语句)          %>
<%！    全局变量，定义方法                     %>
<%=     输出表达式                           %>

指令

page指令<%@ page … %>
page指定的属性:<%@ page language=“java” contentType=“text/html; charset=UTF-8” pageEncoding=“UTF-8”%>
language:jsp页面使用的脚本语言
import:导入的类
pageEncoding:jsp文件自身编码 jsp->java
contentType:浏览器解析jsp的编码

注释

html注释 可以被客户通过浏览器查看源码所看到
java注释// /…/
jsp注释<%-- --%>

Jsp内置对象(自带的，不需要new也能使用的对象)9个

pageContext

JSP页面容器

request:请求对象

请求对象,存储客户端向服务端发送的请求信息

request.getRequestDispatcher(“–.jsp”).forward(request, response);//请求转发
request.setCharacterEncoding(“utf-8”)//设置post方式编码
String … = request.getParameter()//根据请求的字段名Key(input标签的属性值)，返回字段值value
String[] … = request.getParameterValues()//根据请求的字段名Key,返回多个字段值value
ServletContext getServletContext() 获取项目的ServletContext对象
get/post请求方式的区别(method=“post/get”)
get方式在地址栏显示请求信息
文件上传必须使用post

response:响应对象

void addCookie(Cookie cookie) 服务端向客户端cookie对象
void sendRedirect(String location) throws IOException 页面跳转的一种方式:重定向
void setContetType(String type)设置服务端的响应编码
重定向和请求转发的区别
1.请求转发地址栏不发生改变，重定向改变
2.请求转发保留第一次请求的数据，重定向不保留
3.请求次数不相同

session:会话对象

(存在于服务端)

Cookie(存在于客户端,不是内置对象)new:Cookie对象是由服务端产生的，在发送给客户端保存，相当于本地缓存
作用:提高访问服务端的效率，但是安全性较差
Cookie: key=value javax.servlet.http.Cookie
public Cookie(String name,String value)构造方法
String getName()获取name
String getValue()获取value
void setMaxAge(int expiry)设置最大有效期(秒)
服务端发送给客户端Cookie
1.response.addCookie(Cookie cookie)//服务端增加Cookie
2.页面跳转(转发，重定向)
3.客户端获取Cookie:request.getCookies()
客户端在第一次请求服务端是，如果发现此请求没有JsessionID,则会创建一个拥有JsessionID的 cookie,并返回给客户端
session(会话)
session机制:客户端第一次访问服务端,服务端会产生一个session对象(用于保存该客户端的信息), 并且每一个session对象,都会有一个唯 一的sessionID,用于区分其他session,服务端又会产生 一个Cookie对象并且该cookie的name=JSESSIONID,value=服务端sessionID的值,然后服务端 在响应客户端的同时，将该cookie发送给客户端,因此,客户端的cookie就可以和服务端的 session一一对应(JSESSION=sessionID)
session方法
String getId():获取sessionID
boolean idNew():判断是否是第一次访问
void invalidata():使session失效 (退出登录,注销)
void setAttribute()
object getAttribute()
void setMaxInactiveInterval(秒): 设置最大有效非活动时间
int getMaxInactiveInterval(秒): 获取最大有效非活动时间
cookie和session的区别
session保存在服务端，cookie保存在客户端
session服务端较为安全
Cookie保存String(字符串)类型,session保存的是object类型

application:全局对象

String getContextPath()获取虚拟路径
String getRealPath()获取绝对路径(虚拟路径相对的绝对路径)

config:配置对象

服务器配置信息

out:输出对象

向客户端输出内容

page:当前JSP页面对象

相当于java中的this

exception:异常对象

四种范围对象：(小->大)

pageContext

(JSP页面容器)(page对象)当前页面有效

request

请求对象；同一次请求有效 ,请求转发后有效，重定向后无效

session

(存在于服务端)(会话对象)；一次会话有效

application

(全局对象)；全局有效(整个项目有效)

在servlet中使用范围对象

request：
	request.setAttribute();
	reuqest.getAttribute();
	request.removeAttribute();
	request.getParameter();
session
	//获取session对象
	HttpSession session = request.getSession();
	/使用					
	session.setAttribute();
	session.getAttribute();
	session.removeAttribute();	
application（ServletContext上下文）
	//获取application
	ServletContext application = this.getServletContext();
	//使用
	application.setAttribute();
	application.getAttribute();
	application.removeAttribute();

JDBC

java操作数据库

JDBC API

提供各种操作访问接口 (DriverManager,Connection,Statement(PreparedStatement),ResultSet)

过程

1.java程序与数据库建立连接

2.java程序向数据库发送sql语句

3.数据库向java程序返回处理结果

DriverManager

加载jdbc驱动

Connection

与数据库创建连接(通过DriverManager产生)

Connection产生操作数据库的对象
1.产生Statement对象:connection.createStatement()

​ 2.产生PreparedStatement对象:connection.prepareStatement()

​ 3.产生CallableStatement对象:connection.prepareCall()

Statement(PreparedStatement)

增删改查,sql语句，通过Connection产生的

推荐使用子类PreparedStatement,有效防止sql注入

Statement

Statement操作数据库(用户名:任意值’ or 1=1 – 密码:任意值 也会登陆成功):

​ 增删改:executeUpdate()

​ 查询:executeQuery()

PreparedStatement

PreparedStatement操作数据库(有效防止sql注入):

​ 增删改:executeUpdate()

​ 查询:executeQuery()

​ 赋值操作:setXXX()

CallableStatement

CallableStatement:调用数据库中的存储过程/存储函数(通过Connection产生的)

​ connection.prepareCall(参数:存储过程/存储函数名)

​ 参数格式:存储过程:(无返回值，用out参数代替) {call 存储过程名(参数列表)} 存储函数:(有返回值return) {? = call 存储函数名(参数列表)}

ResultSet

返回的结果集(通过Statement产生的)

next():光标下移,判断是否有下一条数据 true/false

previous():光标上移,判断是否有上一条数据 true/false

getXXX():根据get获取具体的字段值

JDBC访问数据库的基本步骤

1.导入驱动程序,加载具体的驱动类(Class.forName(driver))

2.与数据库建立连接(connection = DriverManager.getConnection(url, user, password)😉

3.发送sql语句,执行(pstmt = connection.prepareStatement(sql))

4.如果是查询,处理结果集(rs = pstmt.executeQuery())

JDBC处理大文本数据

mysql[text],oracle[clob]及二进制数据oracle[BLOB]

oracle[clob]: reader writer

​ 1.先用pstmt的？代替小说内容(占位符)

​ 2.再通过pstmt.setCharacterStream(第几个占位符,Reader,小说长度((int)file.length()))将 上一个的占位符替换为流形式的小说(第三个参数是int类型)

BLOB: inputStream OutputStream

JSP访问数据库

//1.获取Connection
	//定义四个字符串
		String url = "jdbc:mysql://localhost:3306/test";//数据库地址
		String user = "root";//用户名
		String password = "123456";//密码
		String driver = "com.mysql.jdbc.Driver";//驱动类的全类名
		
		ResultSet rs = null;
		PreparedStatement pstmt = null;
		Connection connection = null;
		try {
			//1.1加载并注册驱动类
			Class.forName(driver);
			//1.2获取链接
			connection = DriverManager.getConnection(url, user, password);
			//System.out.println(connection);
			//2.sql      ?占位符
			String name = request.getParameter("name");
			String pwd = request.getParameter("pwd");
			String sql = "select count(*) from user where username=? and userpwd=?";
			//3.创建PreparedStatement(发送sql),通过连接获取
			pstmt = connection.prepareStatement(sql);
			//4.根据情况占位符赋值    第几个问号      值
			pstmt.setString(1, name);
			pstmt.setString(2, pwd);
			//5.发送sql,执行查询
			rs = pstmt.executeQuery();
			//6.操作结果集
			int count = -1;
			if(rs.next()) {
				count = rs.getInt(1);
			}
			if(count>0){
				//System.out.print("登陆成功!");
				out.print("登陆成功!");
			}else{
				//System.out.print("登陆失败!");
				out.print("登陆失败!");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//7.释放资源
			try {
				if(rs!=null) {
				rs.close();
				}
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			try {
				if(pstmt!=null) {
				pstmt.close();
				}
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			try {
				if(connection!=null) {
				connection.close();
				}
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

JavaBean

将jsp中某一操作(登陆，注册)的代码转移到Xxx.java文件中，其中Xxx类就称之为JavaBean

JavaBean的作用:

​ 1.减轻jsp的复杂度

	  2.提高代码复用(以后任何地方的登录操作，都可以通过Xxx实现)，增强代码健壮性

JavaBean(就是一个java类)的定义:满足以下两点就可以称为Javabean

​ 1.public修饰的类，public的无参构造

​ 2.所有属性都是private，并且提供set/get(如果是boolean类型，则get可以替换为is)

使用成面，JavaBean分为两大类:

​ 1.封装业务逻辑的JavaBean 对应于操作

​ 2.封装数据的JavaBean (实体类) 对应于数据库中的一张表

MVC设计模式

M:Model模型 V:View视图 C:Controller控制器

M: 功能 使用JavaBean来实现

V:用于展示以及与用户交互 使用前端技术(html,css,jsp,js,jquery)来实现

C:接受视图请求，将请求跳转到模型进行处理；模型处理完毕后，再将处理结果返回给请求处. 可以

用jsp实现(但是不推荐)一般使用Servlet实现

Servlet

Java类必须符合一定的规范:

​ 1.必须继承javax.servlet.http.HttpServlet

​ 2.必须重写其中的doGet()或doPost()方法

​ doGet():用于接收或处理所有get提交方式的请求

​ doPost():用于接收或处理所有post提交方式的请求

要想使用Servlet，必须配置Servlet2.5:web.xml
Servlet3.0:@WebServlet

Eclipse可以快速生成Servlet(继承，重写，web.xml)

Servlet生命周期: 5个阶段

加载->初始化init()->服务->销毁->卸载

加载和卸载:是Servlet容器自动处理

初始化init():该方法会在Servlet被加载并实例化以后执行，默认第一次访问Servlet时会被执行(只执行这一次)

​ 可以修改为tomcat启动时自动执行
​ Servlet2.5:在web.xml中servlet里面添加1

服务service() ->doGet(),doPost() 调用几次，执行几次

销毁destroy():Servlet被系统回收时执行 关闭tomcat服务时，执行一次

Servlet API

由两个软件包组成 1.对应于HTTP协议的软件包 2.对应于除了HTTP协议以外的其他软件包

​ 即Servlet API可以适用于任何通信协议

Servlet继承关系

ServletConfig:接口

​ ServletContext getServletContext() 获取Servlet上下文对象 !!!就是application

​ 方法:String getInitParameter(String name)

			  在当前web容器范围内，获取名为name的参数值(初始化参数)

​ String getInitParameter(String name)

​ 在当前Servlet范围内，获取名为name的参数值(初始化参数)

三层架构

与MVC设计模式的目标一致,都是为了解耦合,提高代码复用率。区别是二者对项目理解的角度不同

三层组成

表示层(视图层)
-表示层前台代码:对应于MVC的View，用于界面的显示，以及用户的交互 (jsp,js,html,css等web 前端技术)
-表示层后台代码：对应于MVC中的Controller，用于页面的控制跳转，以及调用业务逻辑层
Servlet(SpringMVC，Struts2)
业务逻辑层(Service层) – 加入接口
-接收表示层的请求调用
-组装数据访问层，带逻辑性的操作
数据访问层(Dao层)–加入接口
-直接访问数据库的操作

过程

表示层前台代码——>表示层后台代码——>业务逻辑层 调用 数据访问层——>返回给表示层后台代码

三层间的关系

上层将请求传递给下层，下层处理后返回给上层(上层依赖于下层)

三层优化

加入接口

建议面向接口开发：先接口-再实现类 ----service，dao加入接口

接口与实现类的命名规范
接口: IXxxService IXxxDao
实现类: XxxServiceImpl XxxDaoImpl

使用接口/实现类时，推荐写法
接口 x = new 实现类();

DBUtil

数据库帮助类，解决代码冗余，简化Dao层的代码量

建议写在xxx.util 包里

方法重构

把多个方法相同的代码提炼出来，单独写到一个方法里，然后引入该方法

分页

要实现分页，必须知道某一页的数据从哪里开始，到哪里结束

mysql从0开始计数，oracle从1开始计数

mysql实现分页的语句： limit 从哪里开始，持续多少条数据
select * from 表名 limit （页数-1）*页面大小，页面大小
SET @stmt = CONCAT(‘select * from person limit ‘,(页数-1)*页面大小,’,’,页面小,‘’);PREPARE r FROM @stmt;EXECUTE r;

oracle实现分页 ：
select * from student where sno >= (n-1)10+1 and sno < n10; --此种写法的前提是必须是id 连续，否者无法满足每页显示足够的数据
select * from (select rownum r,t.* from (select s.* from student s order by sno asc) t) where r>= (n-1)10+1 and r < n10;

分页实现

​ 5个变量（5个属性）

​ 1.数据总数 --查数据库 select count(*) from 表;

​ 2.页面大小（每页显示的数据条数） --用户自定义

​ 3.总页数 --程序自动计算

​ 4.当前页（页码） – 用户自定义

​ 5.当前页的对象集合（实体类集合）：每页显示的所有数据的集合 --查数据库，分页sq

上传

1.引入两个jar

​ apache:commons-fileupload.jar组件 ,commons-fileupload.jar依赖于commons-io.jar

2.代码

前台jsp：

表单提交方式必须为post
在表单中必须增加一个属性, enctype = “multipart/form-data”

后台servlet：

注意问题：

​ 上传的目录upload：

​ 1.如果修改代码在tomcat重新启动时会被删除

​ 原因：当修改代码时，tomcat会重新编译一份class并且重新部署（重新创建各种目录）

​ 2.如果不修改代码不会被删除

​ 因为为了防止上传目录丢失

​ 1.虚拟路径

​ 2.直接更换上传目录到非tomcat目录

限制上传：类型，大小

​ 对文件的限制条件要放到parseRequest之前

下载

！不需要依赖于任何jar包

1.用户发请求(a href / form)，请求servlet

2.servlet通过文件的地址，将文件转为输入流，读到Servlet中

3.通过输出流，将刚才已经转为输入流的文件，输出给用户

注意：下载文件需要设置两个响应头：response.addHeader(“content-Type”, "application/octet-

stream");//设置为二进制类型

​ response.addHeader(“content-Disposition”, “attachment;filename=”+filename);

EL表达式

表达式语言

可以替代jsp中的Java代码

${域对象Scope.域对象中的属性.属性}

EL操作符
点操作符 . --使用方便

​ 中括号操作符 [] --功能强大，可以包含特殊符号(. - ),可以获取变量值，可以访问数组

获取map属性

empty运算符判断一个值是否位null，或者不存在，如果为空或者不存在，为true

EL表达式的隐式对象(不需要new就能使用的对象)

1.作用域访问对象(EL域对象)
pageScope
requestScope
sessionScope
applicationScope
注意：如果不指定域对象，则默认会根据从小到大的顺序依次取值

2.参数访问对象：获取表单数据
${param}
${paramValues}

3.JSP隐式对象
pageContext

在jsp中可以通过pageContext获取其他的jsp隐式对象；因此要在EL中使用jsp隐式对象，就可以通过

pageContext间接获取

JSTL

比EL更加强大

需要引入两个jar包： jstl.jar ,standard.jar

然后引入taglib ：<%@ taglib uri=“http://java.sun.com/jsp/jstl/core” prefix=“c” %>

–其中prefix="c"代表前缀

核心标签库

通用标签库

<c:set>赋值语句
     <c:set var="变量名" value="变量值" scope="作用域" />
     1.在某个作用域(4个范围对象)中给某个变量赋值
           <c:set var="name" value="zhangsan" scope="request" />
           ${requestScope.name } <br>
     2.在某个作用域(4个范围对象)中给某个对象的属性赋值  --这种写法不能指定scope
          <c:set target="${requestScope.student}" property="name" value="zxs"/>
          ${requestScope.student.name}<br>
<c:out>显示
     <c:out value="${requestScope.student.name}" default="当值为空时显示的默认值"/>
     <c:out value="${requestScope.student.name}"/>
<c:remove>删除属性
     <c:remove var="a" scope="request"/>

条件标签库

选择
     单重选择<c:if test=""> </c:if>
     多重选择<c:choose> 
                 <c:when test="">  </c:when>
                 <c:when test="">  </c:when>
                 ...
                 <c:otherwise> </c:otherwise>
            </c:choose>

迭代标签库

循环
    1. <c:forEach begin="开始值" end="结束值" step="递增几">
             ...
       </c:forEach>
    2.遍历数组
       <c:forEach var="name" items="${requestScope.names }">
             ${name }<br>
       </c:forEach>

过滤器

-请求和响应时都会被拦截

-需要等待过滤器放行

1.实现一个Filter接口

2.重写里边的方法[init(),destroy()原理和执行时机同servlet一致]

3.配置过滤器，类似servlet

4.通过doFilter()处理拦截，并且通过chain.doFilter(request, response);放行请求

 filter映射
     <url-pattern>/MyServlet</url-pattern>    --只拦截MyServlet的请求
     <url-pattern>/*</url-pattern>            --拦截所有的请求

通配符

dispatcher请求方式
request：拦截HTTP请求get，post
forward：只拦截通过请求转发方式的请求
include：只拦截通过request.getRequestDispatcher(“”).include()或通过<jsp:include page=“”/>此种方法发出的请求
error:只拦截<error-page>发出的请求

过滤器链

可以配置多个过滤器

通过<filter-mapping>决定过滤器先后顺序

<!-- 配置过滤器 -->
<filter>
      <filter-name>MyServlet</filter-name>
      <filter-class>org.jnxy.filter.MyFilter</filter-class>
</filter>
<filter-mapping>
      <filter-name>MyServlet</filter-name>
      <url-pattern>/MyServlet</url-pattern>
      <dispatcher>REQUEST</dispatcher>
      <dispatcher>FORWARD</dispatcher>
</filter-mapping>

监听器

开发步骤

​ 1.编写监听器，实现接口

​ 2.配置web.xml

监听对象

request ,session , application

监听对象的创建和销毁

​ request: ServletRequestListener

​ session: HttpSessionListener

​ application: ServletContextListener

​ 每个监听器各自提供了两个方法：监听开始，监听结束的方法

<!-- 配置监听器 -->
<listener>
        listener-class>org.jnxy.listener.CSRListener</listener-class>
</listener>

ServletContext：在servlet容器启动时自动创建

监听对象中属性的变更

request: ServletRequestAttributeListener

session: HttpSessionAttributeListener

application: ServletContextAttributeListener

session对象的四种状态

监听session对象的绑定和解绑：HttpSessionBindingListener（不需要配web.xml）

监听session对象的钝化和活化：HttpSessionActivationListener（不需要配web.xml）

1.绑定

将对象保存在session里边，称为session的绑定 session.setAttribute(“a”,xxx);

将对象a绑定到session

2.解绑

将对象从session中删除，称为sessio的解绑 session.removeAttribute(“a”);

将对象a从session中解绑

3.钝化

将session对象从服务器内存移动到硬盘 内存->硬盘

4.活化

将session对象从服务器内存移动到硬盘 内存->硬盘

如何钝化活化

配置tomcat安装目录/conf/context.xml

钝化活化的本质就是序列化，反序列化：序列化，反序列化需要实现接口Serializable

总结：钝化，活化实际是通过context.xml进行配置而进行的

​ 活化：session获取某一个对象时，如果该对象在内存中不存在，则直接尝试从之前钝化的文件中获取

​ HttpSessionActivationListener只是在钝化活化时进行监听

​ 需要实现接口Serializable

Ajax

异步js和xml

异步刷新技术：如果网页中有个地方需要修改，异步刷新可以使：只刷新需要需改的地方，而页面中的其他部分保持不变

实现方式

​ 1.js

​ ！2.jquery

js实现Ajax

依赖于XMLHttpRequest对象

XMLHttpRequest对象的方法

​ open(方法名(提交方式get/post),服务器地址,true) 与服务端建立连接

​ send()

​ get: send(null)

​ post: send(参数值)

​ setRequestHeader(hearder,value)

​ get: 不需要设置此方法

​ post： 需要设置

​ a.如果请求元素中包含文件上传

​ setRequestHeader(“Content-Type”,“multipart/form-data”);

​ b.如果请求元素中不包含文件上传

​ setRequestHeader(“Content-Type”,“application/x-www-form- urlencoded”);

XMLHttpRequest对象的属性

​ readyState:请求状态

只有状态4代表请求完成

status:响应状态

只有200代表响应正常

onreadystatechange:回调函数

responseText：相应格式为String

responseXML：相应格式为XML

jquery实现Ajax（推荐）

1.$.ajax({

url:服务器地址,

请求方式:get/post,

data：请求数据,

success:function(result,testStatus){

​ 请求成功进入

},

error:function(xhr,errorMessage,e){

​ 请求失败进入

}

})

2.$.get(

服务器地址,

请求数据,

function(result){

},

预期返回值类型()

)

3.$.post(

服务器地址,

请求数据,

function(result){

},

预期返回值类型()

)

IDEA部署web项目

JNDI

java命名与目录接口

jndi：将某一个资源（对象），以配置文件（tomcat/conf/context.xml）的形式写入

实现步骤：1.在tomcat/conf/context.xml中

<Environment name="jndiName" value="jndiValue" type="java.lang.String"/>

​ 2.在jsp中使用

<%  
Context context = new InitialContext();  
String testName = (String) context.lookup("java:comp/env/jndiName"); 
out.print(testName);
%>

连接池

常见连接池：Tomcat-dbcp / dbcp / c3p0 / druid

数据源DataSource（javax.sql.DataSource） > 数据库连接池 ； 数据源包含与连接池 ； 可以用数据源管理连接池

连接池的核心： 以前直接指向数据库，现在指向数据源

获取DataSorce对象，dataSorce.getConnection() 获取Connection对象

数据库访问核心 ->pstmt/stmt->connection->直接数据库/数据源ds.getConnection()

Tomcat-dbcp

类似jndi ，在context.xml中配置数据库 ； 在web.xml中配置 ；更改连接对象Connection的获取方式

dbcp

jar包 commons-dbcp.jar

dbcp获取DataSorce对象的两种方式 ： BasicDataSource ， BasicDataSourceFactory

BasicDataSource 方式

硬编码方式

通用： NoClassDefFoundError异常 ：缺少jar包

1.new BasicDataSource（） 对象

2.set 各种属性

public static DataSource getDataSourceWithDbcp(){
        BasicDataSource dbcp = new BasicDataSource();
        dbcp.setDriverClassName("oracle.jdbc.driver.OracleDriver");
        dbcp.setUrl("jdbc:oracle:thin:@127.0.0.1:1521:ORCL");
        dbcp.setUsername("scott");
        dbcp.setPassword("orcl");
        dbcp.setInitialSize(20);
        dbcp.setMaxActive(10);
        return dbcp;
}

DataSource 是所有sql数据源的上级类 , BasicDataSource 是dbcp类型的数据源

BasicDataSourceFactory方式

配置方式（.properties文件）

dbcpconfig.properties ， 编写方式为 key=value 形式

driverClassName=oracle.jdbc.driver.OracleDriver
url=jdbc:oracle:thin:@127.0.0.1:1521:ORCL
username=scott
password=orcl

 public static DataSource getDataSourceFactory(){
        DataSource dbcp = null;
        Properties props = new Properties();
        InputStream in = new DbcpDemo().getClass().getClassLoader().getResourceAsStream("dbcpconfig.properties");
        try{
            props.load(in);
            //核心
            dbcp = BasicDataSourceFactory.createDataSource(props);
        }catch (Exception e){
            e.printStackTrace();
        }
        return dbcp;
}

c3p0

jar: c3p0.jar ; c3p0-oracle-thin-extras.jar ; mchange-commons-java.jar

两种方式： 硬编码，配置文件 （c3p0-config.xml文件）;

合二为一，通过ComboPooledDataSource的构造参数区分,如果无参：硬编码；如果有参：配置文件

ComboPooledDataSource 是c3p0类型的数据源

oracle修改密码

在管理员状态改 sqlplus / as sysdba;

alter user scott identified by tiger;

//硬编码
ComboPooledDataSource c3p0 = new ComboPooledDataSource();
try {
        c3p0.setDriverClass("oracle.jdbc.driver.OracleDriver");
    } catch (PropertyVetoException e) {
   e.printStackTrace();
}
c3p0.setJdbcUrl("jdbc:oracle:thin:@127.0.0.1:1521:ORCL");
c3p0.setUser("scott");
c3p0.setPassword("orcl");

<!--配置文件  c3p0-config.xml-->
<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <!--默认-->
    <default-config>
        <property name="user">scott</property>
        <property name="password">orcl</property>
        <property name="driverClass">oracle.jdbc.driver.OracleDriver</property>
        <property name="jdbcUrl">jdbc:oracle:thin:@127.0.0.1:1521:ORCL</property>
    </default-config>

    <!--自定义-->
    <named-config name="hyf">
        <property name="user">scott</property>
        <property name="password">orcl</property>
        <property name="driverClass">oracle.jdbc.driver.OracleDriver</property>
        <property name="jdbcUrl">jdbc:oracle:thin:@127.0.0.1:1521:ORCL</property>
    </named-config>
</c3p0-config>

ComboPooledDataSource c3p0 = new ComboPooledDataSource("hyf");

所有连接池的思路：1.硬编码 ， new某个连接池数据源的对象 ds = new XxxDataSource() ，ds.setXxx() ， return ds 。

​ 2.配置文件 ， ds = new XxxDataSource() ; 加载配置文件 ，return ds。

数据源工具类

dbcp，c3p0 ,druid

ApacheDbutils

下载commons-dbutils-1.7.jar ，其中包含几个重点类：

​ DbUtils ， QueryRunner ， ResultSetHandler

DbUtils：打开/关闭链接，提交事务，辅助

QueryRunner：增删改查

ResultSetHandler：如果是查询，则需要ResultSetHandler处理结果集，ResultSetHandler是一个接口，有很多实现类

​ ArrayHandler实现类：返回结果集中的第一行数据,并用Object[] 接收

​ ArrayListHandler实现类：返回结果集中的全部数据，用List<Object[]> 接收

​ BeanHandler实现类：返回结果集中的第一行数据,并用对象javabean 接收

​ BeanListHandler实现类：返回结果集中的全部数据，用List<对象javabean> 接收

​ BeanMapHandler实现类：

​ MapHandler实现类： 只能保存一行数据{ id=1,name=‘zs’}

​ MapListHandler实现类：

​ KeyedHandler实现类：

​ ColumnListHandler实现类：把结果集中的某一列保存到list中

​ ScalarHandler实现类： 查询单值结果集 select count(*) from Xxx;

反射通过无参构造创建对象

iverClass">oracle.jdbc.driver.OracleDriver
jdbc:oracle:thin:@127.0.0.1:1521:ORCL

```java
ComboPooledDataSource c3p0 = new ComboPooledDataSource("hyf");

所有连接池的思路：1.硬编码 ， new某个连接池数据源的对象 ds = new XxxDataSource() ，ds.setXxx() ， return ds 。

​ 2.配置文件 ， ds = new XxxDataSource() ; 加载配置文件 ，return ds。

数据源工具类

dbcp，c3p0 ,druid

ApacheDbutils

下载commons-dbutils-1.7.jar ，其中包含几个重点类：

​ DbUtils ， QueryRunner ， ResultSetHandler

DbUtils：打开/关闭链接，提交事务，辅助

QueryRunner：增删改查

ResultSetHandler：如果是查询，则需要ResultSetHandler处理结果集，ResultSetHandler是一个接口，有很多实现类

​ ArrayHandler实现类：返回结果集中的第一行数据,并用Object[] 接收

​ ArrayListHandler实现类：返回结果集中的全部数据，用List<Object[]> 接收

​ BeanHandler实现类：返回结果集中的第一行数据,并用对象javabean 接收

​ BeanListHandler实现类：返回结果集中的全部数据，用List<对象javabean> 接收

​ BeanMapHandler实现类：

​ MapHandler实现类： 只能保存一行数据{ id=1,name=‘zs’}

​ MapListHandler实现类：

​ KeyedHandler实现类：

​ ColumnListHandler实现类：把结果集中的某一列保存到list中

​ ScalarHandler实现类： 查询单值结果集 select count(*) from Xxx;

反射通过无参构造创建对象

Java 中 对应的 Oracle 默认的数值类型 BigDecimal