url匹配的三种写法
/*
/*.do
/juedui
session:
1.什么是session?有什么用?
当我们进入邮箱的时候，会做很多操作，比如查看信件，写信等等，从登录到结束的这段时间叫做用户的会话的时间，http是无状态的，那么它如何处理不同的用户登录他们的邮箱，返回不同的数据呢？应该是根据他们的信息（如名字，ip等），那就需要在用户发送一系列请求的时候，我都应该知道用户的名字,ip等信息，这个信息怎么知道呢？session对象可以做到在用户的整个会话过程中，保存用户的信息，从而给用户返回正确的页面
2.session常用的方法
request.getSession(false)
返回这个请求中的session对象，如果在请求中没有session对象，并且参数为true,那么就新创建一个对象，如果为false，并且请求中没有session对象，那么返回null
保存一些信息：session.setAttribute()
得到信息：session.getAttribute()
会话结束session.invalidate()
3.设置超时：
<session-config>
<session-timeout>30</session-timeout>
</session-config>
也可以使用方法：setMaxInactiveInterval()
4.session的生命周期和可见范围：
比较长,可以设置会话的时间，很多情况，可见范围也比较广泛
在servlet中session的生命周期：
session的产生
请求--servlet容器：容器会自动创建一个session--servlet类--响应：将session的id以cookie的形式存储到请求方，当再请求的时候，我们可以通过客户端中的sessionID得到sessionID对象，找到里面的信息，从而给出相应得数据
session的结束
用户关闭浏览器的时候
session过期：在有限期内没有进行任何动作
调用invalidate(),让容器为session释放所有资源
5.response.encodeURL():
我们知道，我们可以通过客户端中的sessionID找到相应的信息的，这个sessionID是以cookie方式存储的
那么，假如浏览器不支持cookie，应该怎么办呢？
解决方法：调用response.encodeURL()这个方法判断如果客户端不支持cookie，那么在原来的url中加个参数，这个参数就是sessionID,这样就保证了对该用户信息的查找
cookie:
1.什么是cookie?有什么用？和session有什么区别？
用来保存用户的信息，保存在客户端，比如说：登陆一个邮箱的时候，有一个有效期，是将信息保存一年还是一个月等等，这个功能可以由cookie实现，cookie将信息存储在客户端里，当用户再次登陆的时候，会从客户端中查找这个信息
当创建一个session的时候会自动创建一个cookie,他们的区别在于session存储在服务器端
而cookie存储在客户端上
2.cookie的常用方法：
创建一个cookie:Cookie user = new Cookie("user", "admin");key value对
发送到客户端response.addcookie(usre);
从客户端得到cookie:request.getCookies()
设置有效期：setMaxAge(秒)
如果浏览器不支持cookie:response.encodeURL();
在tomcat中配置数据源：
在tomcat中，不能自己创建数据源对象，所有的数据源对象都是由jndi管理，所以要先创建jndi
方法一：
1.进入管理平台，data sources->create new data source
jndi name:bind(name)
max wait for connection:里面有多少个连接
max wait:连接等待时间
conmmit changes:完成
max.idie.connections: 如果没有人用，只开指定数量的连接
2.conf->server.xml 前十行中找<resources>标签，复制到应用程序的MANIFEST中的context.xml中
<Context>
<Resource
name="jdbc/ora20"
type="javax.sql.DataSource"
password="open123"
driverClassName="oracle.jdbc.driver.OracleDriver"
maxIdle="2"
maxWait="5000"
username="openlab"
url="jdbc:oracle:thin:@192.168.0.20:1521:tarena"
maxActive="4"/>
</Context>
3.在web.xml中添加这些代码
<resource-ref>
<description>DB Connection</description>
<res-ref-name>jdbc/ora20</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
4.程序员写代码
Context ct=new InitialContext()
Ct. ct.lookup(“java:comp/env/jdbc/ora20”)
filter:过滤器
1.servlet链的原理和产生的问题?
用户请求(url)-->servlet1(解密)-->servlet2(打包)-->servlet3(响应数据)
好处:简化,专用,复用,但是也有问题,耦合问题,每个servlet依赖于上一个servlet
filter可以解决这个问题,因为下一个filter不需要上一个filter传递url,他们依赖容器
2.什么是filter?有什么用?
用户请求(url)-->filter(n)-->servlet(n)
filter是在servlet,jsp,html请求之前和响应之后作一些处理的
作用:过滤,在执行servlet,jsp,html之前和之后执行这个过滤器,可以跟踪用户状态,身份验证,字符转换等
3.常用方法?如何使用filter?
必须实现filter接口
init():容器创建filter对象后,调用这个初始化方法,在这个方法里可以取初始化参数
doFilter():过滤方法,过滤指定的url,FilterChain参数可以调用下一个filter
destroy():容器在销毁filter对象前调用这个方法,用来释放资源的
web应用
知识点：过滤器
程序目标：
用户登录，如果输入yuchen,123，显示成功页面，并保存会话对象，判断会话状态使用过滤器实现
名字：lab
目录结构：
根目录：
\lab
\lab\JS
\lab\pages
\lab\pice : login.html success.html
\lab\WEB-INF : web.xml
\WEB-INF\classes
\WEB-INF\lib
\WEB-INF\src : TestFilter.java,TestServlet.java
web.xml:
<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
version="2.4">
<filter>
<filter-name>TestFilter</filter-name>
<filter-class>Filter.TestFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>TestFilter</filter-name>
<url-pattern>/login.html</url-pattern>
</filter-mapping>
<servlet>
<servlet-name>TestServlet</servlet-name>
<servlet-class>Filter.TestServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>TestServlet</servlet-name>
<url-pattern>/login</url-pattern>
</servlet-mapping>
</web-app>
login.html
<html>
<head>
<title>user login</title>
</head>
<body>
<h3 align="center">User Login</h3>
<hr>
<center>
<form action="/lab/login" method="post">
username:<input type="text" name="user" size="15">
password:<input type="password" name="pwd" size="15">
<input type="submit" value="login">
</form>
</center>
</body>
</html>
success.html
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<h3>登录成功</h3>
</body>
</html>
servlet类
package Filter;
import java.io.IOException;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class TestServlet extends HttpServlet{
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
String username=request.getParameter("user");
String pwd=request.getParameter("pwd");
if("yuchen".equals(username)&&"123".equals(pwd)){
HttpSession session=request.getSession(true);
session.setAttribute("username", username);
session.setAttribute("pwd", pwd);
forward("/pages/success.html",request, response);
}else{
forward("/login",request,response);
}
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
{
// TODO Auto-generated method stub
doGet(request, response);
}
private void forward(String url,HttpServletRequest request,HttpServletResponse response){
RequestDispatcher rd=getServletContext().getRequestDispatcher(url);
try {
rd.forward(request, response);
} catch (ServletException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
filter类
package Filter;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
public class TestFilter implements Filter{
private FilterConfig config=null;
public void destroy() {
// TODO Auto-generated method stub
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,
ServletException {
// TODO Auto-generated method stub
HttpServletRequest hrequest=(HttpServletRequest)request;
HttpSession session=hrequest.getSession(false);
if(session!=null){
RequestDispatcher rd=config.getServletContext().getRequestDispatcher("/pages/success.html");
rd.forward(request, response);
}
}
public void init(FilterConfig config) throws ServletException {
// TODO Auto-generated method stub
this.config=config;
}
}
4．装饰模式：
我们可以在响应之前使用过滤器作个拦截，包装一下response
为什么要包装呢?
如果我们需要servlet响应前，修改一下输出的内容，那么就需要自己创建一个新的输出流，因为，如果使用容器中的response,当close的时候，在过滤器中就不能在使用response了，没有办法加工信息，所以我们需要包装一个response对象，让servlet类使用我们包装的response,这个response有个缓冲区的类，响应得信息都存放到这个缓冲区了，当servlet close和flush的时候，对这个缓冲区的类无效，内容还在，这样我们就可以处理它了
5．通过装饰模式替换字符串：
第一：建立过滤器类
第二：建立包装类，可以包装request,response等对象
第三：过滤器类把这个包装类的对象传递给servlet类，来代替容器创建的对象（request,response）
监听器listener:
1.什么是监听器?有什么用?
基于事件的模式，可以监听session,request等，当他们发生动作的时候，事件响应
2．监听器的写法
第一：写个监听器的类
第二：在web.xml中注册监听器
综合案例：
web应用
程序目标：
用户输入名字和密码：如果正确显示成功页面
程序逻辑：
请求页面（web）--中心控制器(web)--业务动作(web)--service层--data层
模块划分：
1.判断用户名和密码是否正确，如果正确：登陆成功，进入success.html
login.html(web):这个表单将用户输入的数据提交到控制器
控制器(web)：1.得到用户请求的路径"/login.do" 2.调用业务动作(web):业务动作首先得到
表单的数据，然后将数据打包成一个对象，调用service层：调用data层，判断用户名密码是否正确
最终把结果返回给控制器，中央控制器得到一个新的url，进入这个url
2.创建jndi数据库链接池
3.session:用户发送请求(/LoginUI):判断客户会话状态，根据状态作出不同的处理，如果session
不为空，说明已经登陆了，把信息打印出来，否则显示登陆表单
4.Filter:使用filter将响应的信息拦截住，将里面的字符串进行处理，用户发送请求(/LoginUI)
filter做过滤，先把包装好的response对象传递给servlet类，servlet类把信息发送到了我们自定义
的流中，这个流把信息放到了一个缓存中，响应的时候被拦截处理，替换了一些字符，最后返回给用户
5.监听器：监听session的状态
名字：cms
目录结构：
根目录：
\cms
\cms\JS
\cms\pages
\cms\pice :
\cms\WEB-INF : web.xml
\WEB-INF\classes
\WEB-INF\lib
\WEB-INF\src
\src\cms.data.dao:UserDAO.java
\src\cms.data.util:JdbcUtil.java
\src\cms.service.entites:user.java
\src\cms.service.managers:LoginManager.java
\src\cms.web.control.actions:LoginAction.java UserInfo.java
\src\cms.web.control.controller:Controller.java
\src\cms.web.filter:TestFilter.java TestWrapper.java
\src\cms.web.listener:TestSessionListener.java
包说明：
data:jdbc/hibernate 持久层
service:业务层
web：和用户做io
web：页面（html,由servlet生成的页面），中心控制器，action(业务动作)--
service:实体服务对象
web.xml:
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>
cms</display-name>
<filter>
<filter-name>test filter</filter-name>
<filter-class>cms.web.filter.TestFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>test filter</filter-name>
<url-pattern>/LoginUI</url-pattern>
</filter-mapping>
<listener>
<listener-class>cms.web.listener.TestSessionListener</listener-class>
</listener>
<servlet>
<description>
</description>
<display-name>
Controller</display-name>
<servlet-name>Controller</servlet-name>
<servlet-class>
cms.web.control.controller.Controller</servlet-class>
</servlet>
<servlet>
<servlet-name>LoginUI</servlet-name>
<servlet-class>
cms.web.ui.LoginUI</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Controller</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>LoginUI</servlet-name>
<url-pattern>/LoginUI</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
<resource-ref>
<description>DB Connection</description>
<res-ref-name>jdbc/ora20</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
</web-app>
sql:
drop table cms_user;
create table cms_user(name varchar2(30),pwd varchar2(20),age number(3),levels number(5));
insert into cms_user values('yuchen','123',24,0);
login.html:
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Login</title>
</head>
<body>
<form action="/cms/login.do" method="post">
<input type="text" name="user">
<br><input type="password" name="pwd">
<br><input type="submit">
</form>
</body>
</html>
success.html:
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>Login Success !</h1>
</body>
</html>
cms.web.ui:LoginUI.java
/*
* 程序目标：
* 判断客户会话状态，根据状态作出不同的处理
* 程序逻辑：
* 1.得到session
* 2.如果不为空，说明已经登录成功了，因为当用户登录
* 成功了，就创建了一个session，在登录的时候，如果还
* 有这个session当然是已经登录了，然后打印信息
* 3.如果没有登录，那么显示登陆页
*/
package cms.web.ui;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class LoginUI extends HttpServlet{
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
response.setContentType("text/html;charset=gbk");
PrintWriter out=response.getWriter();
HttpSession session=request.getSession(false);
if(session!=null){//说明从客户端得到了当前的session
out.print("你已经登陆了！<br>");
Enumeration em = session.getAttributeNames();
while(em.hasMoreElements()){
String name = (String)em.nextElement();
out.print(name+"-->");
out.print(session.getAttribute(name)+"<br>");
}
}else{
out.println("<form action=\"/cms/login.do\" method=\"post\">");
out.println("/n<input type=\"text\" name=\"comment\">");
out.println("/n<input type=\"text\" name=\"user\">");
// out.println("<br><input type=\"password\" name=\"pwd\">");
// out.println("<br><input type=\"submit\"></form>");
out.println("/n<input type=\"password\" name=\"pwd\">");
out.println("/n<input type=\"submit\"></form>");
}
out.close();
}
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
doGet(request, response);
}
}
web.control.controller:Controller.java
/*
* 程序目标：
* 中央控制器，负责整个web应用的调度
* 1.判断用户名和密码是否正确，如果正确：登陆成功，
* 显示success.html
* 2.如果nextURL是success.html保存用户信息到session中
* 程序逻辑：
* 1.得到url
* 2.调用业务动作：得到给用户返回的页面url
* 3.保存用户信息到session
* 4.打开这个页面
*/
package cms.web.control.controller;
import java.io.IOException;
import java.util.Vector;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import cms.web.control.actions.LoginAction;
public class Controller extends HttpServlet{
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
String url=request.getServletPath();
response.getWriter().print(url);
String nextURL="";
if(url.equals("/login.do")){
nextURL=(new LoginAction()).process(request);
}
if("/pages/success.html".equals(nextURL)){
HttpSession session = request.getSession(true);
session.setAttribute("user", request.getParameter("user"));
Vector v = (Vector)session.getAttribute("comment");
if(v==null){v = new Vector();}
v.add(request.getParameter("comment"));
session.setAttribute("comments",v);
}
RequestDispatcher rd=getServletContext().getRequestDispatcher(nextURL);
rd.forward(request, response);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
doGet(request, response);
}
}
web.control.actions:LoginAction.java
/*
* 程序目标：
* 通过调用服务层组件，判断给用户返回哪个页面
* 程序逻辑：
* 1.得到表单数据
* 2.将数据打包成对象
* 3.调用服务层组件（传递数据对象）判断数据是否正确
* 4.如果正确，返回登陆成功的页面，否则返回登陆页面
*/
package cms.web.control.actions;
import javax.servlet.http.HttpServletRequest;
import cms.service.entites.User;
import cms.service.managers.LoginManager;
public class LoginAction {
public String process(HttpServletRequest request){
String nexturl="";
String userName=request.getParameter("user");
String pwd=request.getParameter("pwd");
UserInfo userinfo=new UserInfo(userName,pwd);
//调用service服务层的组件
LoginManager lm=new LoginManager();
boolean rst=lm.processLogin(userinfo);
if(rst){
nexturl="/pages/success.html";
}else{
nexturl="/LoginUI";
}
return nexturl;
}
}
web.control.actions:UserInof.java
package cms.web.control.actions;
//web:actions:业务动作:把用户的信息打包
public class UserInfo {
private String name;
private String pwd;
public UserInfo(){
}
public UserInfo(String name,String pwd){
this.name=name;
this.pwd=pwd;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
}
web.filter:TestFilter.java
package cms.web.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.HttpServletResponse;
public class TestFilter implements Filter{
private FilterConfig fc=null;
public void destroy() {
// TODO Auto-generated method stub
this.fc=null;
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
// TODO Auto-generated method stub
TestWrapper responseWrapper= new TestWrapper((HttpServletResponse)response);
chain.doFilter(request, responseWrapper);
//得到流中缓冲区里的信息，也就是返回给客户的信息
String content=responseWrapper.getContent();
//将信息中的\n全部替换为<br>
content=content.replaceAll("/n", "<br>");
//将最终结果返回给浏览器
response.getWriter().println(content);
}
public void init(FilterConfig arg0) throws ServletException {
// TODO Auto-generated method stub
this.fc=arg0;
//在这里使用初始化参数
}
}
web.filter.TestWrapper.java
/*
* 程序目标：
* 包装了response对象
* getWriter():这个方法将得到一个我们自己new的输出流
* 并且将这个流的内容存储到缓冲区里
* getContent():显示流里缓冲区中的内容，这样就可以进行
* 修改了
*/
package cms.web.filter;
import java.io.CharArrayWriter;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
public class TestWrapper extends HttpServletResponseWrapper{
private CharArrayWriter cw=new CharArrayWriter();
public TestWrapper(HttpServletResponse response) {
super(response);
// TODO Auto-generated constructor stub
}
@Override
public PrintWriter getWriter() throws IOException {
// TODO Auto-generated method stub
return new PrintWriter(cw);
}
public String getContent(){
return cw.toString();
}
}
web.listener:TestSessionListener.java
/*
* 程序目标：
* 负责监听session对象
* 程序逻辑：
* 当创建session，保存属性，删除属性时，写日志
*/
package cms.web.listener;
import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
public class TestSessionListener implements HttpSessionListener,HttpSessionAttributeListener{
public void sessionCreated(HttpSessionEvent arg0) {
// TODO Auto-generated method stub
//当创建session的时候，发出响应
}
public void sessionDestroyed(HttpSessionEvent arg0) {
// TODO Auto-generated method stub
}
public void attributeAdded(HttpSessionBindingEvent arg0) {
// TODO Auto-generated method stub
}
public void attributeRemoved(HttpSessionBindingEvent arg0) {
// TODO Auto-generated method stub
}
public void attributeReplaced(HttpSessionBindingEvent arg0) {
// TODO Auto-generated method stub
}
}
service.entites:User.java
package cms.service.entites;
public class User {
private String name;
private String pwd;
private int age;
private int levels;
public User(){
}
public User(String name, int age, int levels) {
this.name = name;
this.age = age;
this.levels = levels;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getLevels() {
return levels;
}
public void setLevels(int levels) {
this.levels = levels;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public boolean cheakpwd(String pwd){
boolean rst=false;
if((this.pwd).equals(pwd)){
rst=true;
}
return rst;
}
}
cms.service.managers:LoginManager.java
/*
* 程序逻辑：
* 1.打开数据对象
* 2.调用data层:取和数据对象匹配的数据，打包成对象
* 3.如果这个对象为null,那么登陆失败返回false,否则判断
* 密码是不是正确，如果正确返回true
*/
package cms.service.managers;
import cms.data.dao.UserDAO;
import cms.service.entites.User;
import cms.web.control.actions.UserInfo;
public class LoginManager {
public boolean processLogin(UserInfo userinfo) {
// TODO Auto-generated method stub
String name=userinfo.getName();
String pwd=userinfo.getPwd();
boolean rst=false;
UserDAO dao=new UserDAO();
User user=dao.finByName(name);
if(user!=null){
rst=user.cheakpwd(pwd);
}
return rst;
}
}
cms.data.dao:UserDAO.java
/*
* 连接数据库
*/
package cms.data.dao;
import java.sql.*;
import cms.data.util.*;
import cms.service.entites.User;
public class UserDAO {
public User finByName(String name){
User user=null;
Connection con=null;
PreparedStatement ps=null;
ResultSet rs=null;
String sql="select pwd,age,levels from cms_user where name=?";
try {
// con=ConnectionFactory.getConnection();
con=ConnectionFactory.getConnectionDS("java:comp/env/jdbc/ora20");
ps=con.prepareStatement(sql);
ps.setString(1, name);
rs=ps.executeQuery();
if(rs.next()){
user=new User(name,rs.getInt(2),rs.getInt(3));
user.setPwd(rs.getString(1));
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
JdbcUtil.close(rs, ps,con);
}
return user;
}
}
cms.data.util:ConnectionFactory.java
package cms.data.util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
public class ConnectionFactory {
public static Connection getConnection() throws ClassNotFoundException, SQLException{
Class.forName("oracle.jdbc.driver.OracleDriver");
return DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:name","scott","tiger");
}
public static Connection getConnectionDS(String name){
Connection con=null;
//连接jndi服务器
try {
Context ct=new InitialContext();
DataSource ds=(DataSource) ct.lookup(name);
if(ds!=null){
con=ds.getConnection();
}
} catch (NamingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return con;
}
}
cms.data.util:JdbcUtil.java
package cms.data.util;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class JdbcUtil {
public static void close(ResultSet rs,Statement st,Connection con){
try {
if(rs!=null){
rs.close();
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
st.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
con.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void close(Statement st,Connection con){
close(null,st,con);
}
}