在html中嵌套的java代码<% %>)
动态网页:是否随着时间,地点,用户操作的改变而改变
动态网页需要使用到服务端脚本语言(JSP)
BS,CS各有优势
CS:Client Server 客户端,服务端 不足:
a.如果服务器软件升级,那么全部客户端软件都需要升级
b.维护麻烦
c.每一个客户端都需要安装客户端软件
BS:Broswer Server浏览器,服务器 客户端可以通过浏览器直接访问服务端(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标签中配置
(需要重启tomcat服务器)
2.在conf\Catalina\localhost中新建一个 (项目名).xml 中新增一行
虚拟主机
jsp->java(servlet文件)->class
!!一般而言:修改web.xml,配置文件,java需要重新启动tomcat服务器;但是修改jsp,css,html,js文件不需要重启tomcat服务器
在eclipse中创建的web项目:
浏览器可以直接访问WebContent中的文件,但是WEB-INF中的文件无法通过客户端直接访问, 只能通过请求转发来访问
(跳转有两种方式,一种是请求转发,另一种是重定向)
第一种方法;将tomcat/lib/servlet-api.jar加入项目的构建路径中
第二种方法:右键项目->Build Path->Add library->server Runtime
<% 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页面容器
请求对象,存储客户端向服务端发送的请求信息
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
void addCookie(Cookie cookie) 服务端向客户端cookie对象
void sendRedirect(String location) throws IOException 页面跳转的一种方式:重定向
void setContetType(String type)设置服务端的响应编码
重定向和请求转发的区别
1.请求转发地址栏不发生改变,重定向改变
2.请求转发保留第一次请求的数据,重定向不保留
3.请求次数不相同
(存在于服务端)
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类型
String getContextPath()获取虚拟路径
String getRealPath()获取绝对路径(虚拟路径相对的绝对路径)
服务器配置信息
向客户端输出内容
相当于java中的this
(JSP页面容器)(page对象)当前页面有效
请求对象;同一次请求有效 ,请求转发后有效,重定向后无效
(存在于服务端)(会话对象);一次会话有效
(全局对象);全局有效(整个项目有效)
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();
java操作数据库
提供各种操作访问接口 (DriverManager,Connection,Statement(PreparedStatement),ResultSet)
1.java程序与数据库建立连接
2.java程序向数据库发送sql语句
3.数据库向java程序返回处理结果
加载jdbc驱动
与数据库创建连接(通过DriverManager产生)
Connection产生操作数据库的对象
1.产生Statement对象:connection.createStatement()
2.产生PreparedStatement对象:connection.prepareStatement()
3.产生CallableStatement对象:connection.prepareCall()
增删改查,sql语句,通过Connection产生的
推荐使用子类PreparedStatement,有效防止sql注入
Statement操作数据库(用户名:任意值’ or 1=1 – 密码:任意值 也会登陆成功):
增删改:executeUpdate()
查询:executeQuery()
PreparedStatement操作数据库(有效防止sql注入):
增删改:executeUpdate()
查询:executeQuery()
赋值操作:setXXX()
CallableStatement:调用数据库中的存储过程/存储函数(通过Connection产生的)
connection.prepareCall(参数:存储过程/存储函数名)
参数格式:存储过程:(无返回值,用out参数代替) {call 存储过程名(参数列表)} 存储函数:(有返回值return) {? = call 存储函数名(参数列表)}
返回的结果集(通过Statement产生的)
next():光标下移,判断是否有下一条数据 true/false
previous():光标上移,判断是否有上一条数据 true/false
getXXX():根据get获取具体的字段值
1.导入驱动程序,加载具体的驱动类(Class.forName(driver))
2.与数据库建立连接(connection = DriverManager.getConnection(url, user, password)
3.发送sql语句,执行(pstmt = connection.prepareStatement(sql))
4.如果是查询,处理结果集(rs = pstmt.executeQuery())
mysql[text],oracle[clob]及二进制数据oracle[BLOB]
oracle[clob]: reader writer
1.先用pstmt的?代替小说内容(占位符)
2.再通过pstmt.setCharacterStream(第几个占位符,Reader,小说长度((int)file.length()))将 上一个的占位符替换为流形式的小说(第三个参数是int类型)
BLOB: inputStream OutputStream
//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();
}
}
将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 (实体类) 对应于数据库中的一张表
M:Model模型 V:View视图 C:Controller控制器
M: 功能 使用JavaBean来实现
V:用于展示以及与用户交互 使用前端技术(html,css,jsp,js,jquery)来实现
C:接受视图请求,将请求跳转到模型进行处理;模型处理完毕后,再将处理结果返回给请求处. 可以
用jsp实现(但是不推荐)一般使用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)
加载->初始化init()->服务->销毁->卸载
加载和卸载:是Servlet容器自动处理
初始化init():该方法会在Servlet被加载并实例化以后执行,默认第一次访问Servlet时会被执行(只执行这一次)
可以修改为tomcat启动时自动执行
Servlet2.5:在web.xml中servlet里面添加1
服务service() ->doGet(),doPost() 调用几次,执行几次
销毁destroy():Servlet被系统回收时执行 关闭tomcat服务时,执行一次
由两个软件包组成 1.对应于HTTP协议的软件包 2.对应于除了HTTP协议以外的其他软件包
即Servlet API可以适用于任何通信协议
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 实现类();
数据库帮助类,解决代码冗余,简化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);
表达式语言
可以替代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间接获取
比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>/* --拦截所有的请求
dispatcher请求方式
request:拦截HTTP请求get,post
forward:只拦截通过请求转发方式的请求
include:只拦截通过request.getRequestDispatcher(“”).include()或通过
error:只拦截
可以配置多个过滤器
通过
<!-- 配置过滤器 -->
<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对象的绑定和解绑:HttpSessionBindingListener(不需要配web.xml)
监听session对象的钝化和活化:HttpSessionActivationListener(不需要配web.xml)
将对象保存在session里边,称为session的绑定 session.setAttribute(“a”,xxx);
将对象a绑定到session
将对象从session中删除,称为sessio的解绑 session.removeAttribute(“a”);
将对象a从session中解绑
将session对象从服务器内存移动到硬盘 内存->硬盘
将session对象从服务器内存移动到硬盘 内存->硬盘
配置tomcat安装目录/conf/context.xml
钝化活化的本质就是序列化,反序列化:序列化,反序列化需要实现接口Serializable
总结:钝化,活化实际是通过context.xml进行配置而进行的
活化:session获取某一个对象时,如果该对象在内存中不存在,则直接尝试从之前钝化的文件中获取
HttpSessionActivationListener只是在钝化活化时进行监听
需要实现接口Serializable
异步js和xml
异步刷新技术:如果网页中有个地方需要修改,异步刷新可以使:只刷新需要需改的地方,而页面中的其他部分保持不变
实现方式
1.js
!2.jquery
依赖于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”);
readyState:请求状态
只有状态4代表请求完成
status:响应状态
只有200代表响应正常
onreadystatechange:回调函数
responseText:相应格式为String
responseXML:相应格式为XML
1.$.ajax({
url:服务器地址,
请求方式:get/post,
data:请求数据,
success:function(result,testStatus){
请求成功进入
},
error:function(xhr,errorMessage,e){
请求失败进入
}
})
2.$.get(
服务器地址,
请求数据,
function(result){
},
预期返回值类型()
)
3.$.post(
服务器地址,
请求数据,
function(result){
},
预期返回值类型()
)
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()
类似jndi ,在context.xml中配置数据库 ; 在web.xml中配置 ;更改连接对象Connection的获取方式
jar包 commons-dbcp.jar
dbcp获取DataSorce对象的两种方式 : BasicDataSource , BasicDataSourceFactory
硬编码方式
通用: 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类型的数据源
配置方式(.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;
}
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>
<default-config>
<property name="user">scottproperty>
<property name="password">orclproperty>
<property name="driverClass">oracle.jdbc.driver.OracleDriverproperty>
<property name="jdbcUrl">jdbc:oracle:thin:@127.0.0.1:1521:ORCLproperty>
default-config>
<named-config name="hyf">
<property name="user">scottproperty>
<property name="password">orclproperty>
<property name="driverClass">oracle.jdbc.driver.OracleDriverproperty>
<property name="jdbcUrl">jdbc:oracle:thin:@127.0.0.1:1521:ORCLproperty>
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
下载commons-dbutils-1.7.jar ,其中包含几个重点类:
DbUtils , QueryRunner , ResultSetHandler
DbUtils:打开/关闭链接,提交事务,辅助
QueryRunner:增删改查
ResultSetHandler:如果是查询,则需要ResultSetHandler处理结果集,ResultSetHandler是一个接口,有很多实现类
ArrayHandler实现类:返回结果集中的第一行数据,并用Object[] 接收
ArrayListHandler实现类:返回结果集中的全部数据,用List
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
下载commons-dbutils-1.7.jar ,其中包含几个重点类:
DbUtils , QueryRunner , ResultSetHandler
DbUtils:打开/关闭链接,提交事务,辅助
QueryRunner:增删改查
ResultSetHandler:如果是查询,则需要ResultSetHandler处理结果集,ResultSetHandler是一个接口,有很多实现类
ArrayHandler实现类:返回结果集中的第一行数据,并用Object[] 接收
ArrayListHandler实现类:返回结果集中的全部数据,用List
BeanHandler实现类:返回结果集中的第一行数据,并用对象javabean 接收
BeanListHandler实现类:返回结果集中的全部数据,用List<对象javabean> 接收
BeanMapHandler实现类:
MapHandler实现类: 只能保存一行数据{ id=1,name=‘zs’}
MapListHandler实现类:
KeyedHandler实现类:
ColumnListHandler实现类:把结果集中的某一列保存到list中
ScalarHandler实现类: 查询单值结果集 select count(*) from Xxx;
反射通过无参构造创建对象
Java 中 对应的 Oracle 默认的数值类型 BigDecimal