标签：tomcat xsd 子接口 pass inter 在服务器 llb ESS 个数
public abstract class GenericServlet implements Servlet, ServletConfig, java.io.Serializable public abstract class HttpServlet extends GenericServlet
1) Servlet的实例对象由Servlet容器负责创建；Servlet的方法由容器在特定情况下调用；Servlet容器（tomcat就是其中之一）会在Web应用卸载时销毁Servlet对象的实例。
用servlet接口，创建类实现这个接口；由servlet容器即tomcat来造对象，自动new对象，自动来调用相应的方法来实现功能。
2) 简单可以理解为 Servlet就是用来处理客户端的请求的.
Servlet狭义的概念它的接口以及它的子接口；广义概念上是只要写了类实现了这个接口就称为Servlet；
WEB-INF下的东西服务器可以访问，浏览器不能访问。
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
<!--注册Servlet，即我写了一个类，需要容器tomcat帮我实现造下对象 -->
<servlet>
<!--给当前Servlet起一个名词,可任意指定，通常使用类名作为Servlet的名称 -->
<servlet-name>HelloServlet</servlet-name>
<!--指定Servlet接口实现类的全名称,Servlet容器tomcat会利用反射创建Servlet接口实现类对象 -->
<servlet-class>com.atguigu.servlet.HelloServlet</servlet-class>
</servlet>
<!-- 映射Servlet，即告诉它这个Servlet处于哪个请求的 -->
<servlet-mapping>
<servlet-name>HelloServlet</servlet-name> 类名
<!-- 请求映射地址
/就代表 http://localhost:8080/Web01/这一串;发请求用你写的MyFirstServlet
-->
<url-pattern>/MyFirstServlet</url-pattern>
/后边写什么就是告诉它处理的什么请求，浏览器地址栏访问的
</servlet-mapping>
</web-app>
写一个HelloServlet类实现这个接口
①、写一个类继承它 -- >> implements Servlet继承接口
@Override //用来处理用户请求的方法
public void service(ServletRequest req, ServletResponse res){
}
ServletRequest为一个接口，ServletResponse也是一个接口。
extends HttpServlet{
}
②、自动创建一个类会自动 extends继承HttpServlet类
public abstract class HttpServlet extends GenericServlet {}
public abstract class GenericServlet implements Servlet, ServletConfig,
java.io.Serializable {}
两个方法：
protected void doGet(HttpServletRequest request, HttpServletResponse response) { }
HttpServletRequest request 接口，
public interface HttpServletRequest extends ServletRequest（它也是一个接口） {}
HttpServletResponse response 接口
public interface HttpServletResponse extends ServletResponse（接口） {}
//响应乱码问题: 服务器给浏览器发送的响应信息
res.setContentType("text/html;charset=UTF-8");
//获取一个打印流
PrintWriter writer = res.getWriter();
writer.write("response success!");
writer.print("响应成功");
浏览器页面展示：response success!响应成功
//GET请求的请求乱码问题的解决方案：在Tomcat的server.xml配置文件中的第一个Connector标签中添加属性URIEncoding="UTF-8"
<Connector URIEncoding="UTF-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>
如：注册登录输入中文字符，在后台得到就不至于乱码了；
//POST请求的请求乱码问题的解决方案：request.setCharacterEncoding("UTF-8");
给浏览器响应一个字符串或者一个页面
//解决响应中文乱码问题
response.setContentType("text/html;charset=UTF-8");
PrintWriter writer = response.getWriter();
writer.write("响应成功！");
// writer.write("<!DOCTYPE html>");
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public class HelloServlet implements Servlet {
//它会自动来new HelloServlet，调用service来处理请求；
@Override
public void init(ServletConfig config) throws ServletException {
}
@Override
public ServletConfig getServletConfig() {
return null;
}
@Override //用来处理用户请求的方法
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
System.out.println("收到");
//响应乱码问题:
res.setContentType("text/html;charset=UTF-8");
//获取一个打印流
PrintWriter writer = res.getWriter();
writer.write("response success!");
writer.print("响应成功");
}
@Override
public String getServletInfo() {
return null;
}
@Override
public void destroy() {}
}
ctrl+shift+T 搜索servlet可以导入源码；
public class AutoServlt extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#HttpServlet()
*/
public AutoServlt() {
super();
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//GET请求的请求乱码问题的解决方案：在Tomcat的server.xml配置文件中的第一个Connector标签中添加属性URIEncoding="UTF-8"
//request的作用
//1.获取请求参数
String username = request.getParameter("username");
String password = request.getParameter("password");
System.out.println("GET:" + username);
System.out.println("GET:" + password);
//2.获取项目的虚拟路径
String path = request.getContextPath();
System.out.println(path);
//3.获取转发器并请求转发
RequestDispatcher rd = request.getRequestDispatcher("pages/login_success.html");
rd.forward(request, response);
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
System.out.println("Post请求");
//Post请求乱码
request.setCharacterEncoding("UTF-8");
String username = request.getParameter("username");
String password = request.getParameter("password");
System.out.println("POST:" + username);
System.out.println("POST" + password);
//response的作用
//1.给浏览器响应一个字符串或者一个页面
//解决响应中文乱码问题
response.setContentType("text/html;charset=UTF-8");
PrintWriter writer = response.getWriter();
// writer.write("响应成功！");
// writer.write("<!DOCTYPE html>");
// writer.write("<html>");
//2.重定向
response.sendRedirect(request.getContextPath() + "/pages/login_success.html");
//doGet(request, response);
}
}
Get请求
Post请求
以 / 开头的路径即为绝对路径，它代表的意义不一样；
/ 代表的意义：
如果地址由浏览器解析，那么 / 就代表http://localhost:8080/
1）html标签中的路径
2）重定向中的路径（浏览器发送了第二次请求）
<base href="http://localhost:8080/Web03/"> base标签中的href属性可以让当前页面中的所有相对路径变为绝对路径，它会与其他连接中的地址拼。
如果地址由服务器解析，那么 / 就代表http://localhost:8080/Web_Ex/，比它多了个项目名；
1）web.xml中url-pattern标签中的路径
2）转发中的路径
转发：
A（浏览器）向C（服务器）发请求一次请求，在A不知道的情况下，C在服务器内部从B那拿到2K给了A
重定向：
服务器发送两次请求，两次request请求； A向C发请求，C直接拒绝了，但给它重定向抛了一个地址让它去找B，它又给B发请求。
可以重定向一个页面，也可以重定向一个类等。
提供了对数据库进行增删改查的Dao；
BasicDao类是封装一个对数据库的增删改查的方法（获取连接使用JDBCUtils工具类调用getconnection方法； getBean方法是获取一个对象 ；getBeanList是获取一个集合List）；
UserDao 提供一个接口； 传入的用户名和密码从数据库中查询对应的记录，进行校验；// 调用BasicDao中获取一个对象的方法
UserDaoImpl实现类实现UserDao接口；
JDBCUtils工具类utils实现获取连接和释放连接，使用了DruidDataSourceFactory连接池。
<body>
<!--1.JSP脚本片段作用：用来在里面写Java代码-->
<%
Date date = new Date();
for(int i=0; i<5; i++){
out.println("jsp"); //会输出到页面显示,而System.out.println()在控制台打印;
%>
<h2>out.println("Hello World!");</h2>
<%
}
%>
<!-- 2.JSP表达式作用：用来输出对象 -->
<h2>北京时间: <%=date %></h2>
<%=request.getContextPath() %> <!--页面中输出 /WebJSP -->
</body>
1) JSP全称Java Server Pages，顾名思义就是运行在java服务器中的页面，也就是在我们JavaWeb中的动态页面，其本质就是一个Servlet。
2) 其本身是一个动态网页技术标准，它的主要构成有HTML网页代码、Java代码片段、JSP标签几部分组成，后缀是.jsp
3) 相比于Servlet，JSP更加善于处理显示页面，而Servlet跟擅长处理业务逻辑，两种技术各有专长，所以一般我们会将Servlet和JSP结合使用，Servlet负责业务，JSP负责显示。
4) 一般情况下， 都是Servlet处理完的数据，转发到JSP，JSP负责显示数据的工作
5) JSP的脚本元素
脚本片段是嵌入到JSP中Java代码段，格式以<%开头，%>结尾，两个%号之间就可以编写Java代码了
JSP的表达式； JSP表达式用来直接将Java变量输出到页面中，格式以<%=开头，以%>结尾，中间是我们要输出的内容
6）JSP的9大隐含对象
① out（JspWriter）：相当于response.getWriter()获取的对象，用于在页面中显示信息。
② config（ServletConfig）：对应Servlet中的ServletConfig对象。
③page（Object）：对应当前Servlet对象，实际上就是this。
④ pageContext（PageContext）：当前页面的上下文，也是一个域对象。
url:"${pageContext.request.contextPath}/AjaxServlet", 可用来获取项目虚拟路径；
⑤ exception（Throwable）：错误页面中异常对象
⑥ request（HttpServletRequest）：HttpServletRequest对象
⑦response（HttpServletResponse）：HttpServletResponse对象
⑧ application（ServletContext）：ServletContext对象
⑨ session（HttpSession）：HttpSession对象
7) EL表达式
① EL是JSP内置的表达式语言，用以访问页面的上下文以及不同作用域中的对象 ，取得对象属性的值，或执行简单的运算或判断操作。EL在得到某个数据时，会自动进行数据类型的转换。
② EL表达式用于代替JSP表达式(<%= %>)在页面中做输出操作。
③ EL表达式仅仅用来读取数据，而不能对数据进行修改。
④ 使用EL表达式输出数据时，如果有则输出数据，如果为null则什么也不输出。
⑤ EL表达式的语法:
⑥ EL取值的四个域:
pageScope requestScope sessionScope applicationScope
四个域 page域 范围：当前页面 对应的域对象：pageContext 域对象的类型：PageContext request域 范围：当前请求（一次请求） 对应的域对象：request 域对象的类型：HttpServletRequest session域 范围：当前会话（一次会话） 对应的域对象：session 域对象的类型：HttpSession application 范围：当前Web应用 对应的域对象：application 域对象的类型：ServletContext 四个域对象都有以下三个方法： void setAttribute(String key , Object value) Object getAttribute(String key) void removeAttribute(String key) 四个域对象的使用规则：能用小的就不用大的
<body> <% pageContext.setAttribute("pagekey", "pageValue");//当前页面 request.setAttribute("reqkey", "reqvalue"); //当前一次请求 session.setAttribute("session", "sessionValue"); //当前一次会话 application.setAttribute("application", "appliValue"); //当前web应用 %>
<h2>在当前页面获取属性值</h2> page域的属性值:<%=pageContext.getAttribute("pagekey") %> <!-- 把当前页面转发了就变为null --> <br> request域中属性值:<%=request.getAttribute("reqkey") %> <!-- 连接如超连接 --> <br> session域中属性值:<%=session.getAttribute("session") %> <!-- 把浏览器关了就没了 --> <br> application域中属性值:<%=application.getAttribute("application") %><!--重启下服务器就失效了 --> <!-- 转发到scope2页面 --> <jsp:forward page="/scope2.jsp"></jsp:forward> <br> <a href="/WebJSP/scope2.jsp">去scope2页面</a> <!-- 超链接,浏览器,2次请求 --> </body>
cope2.jsp <body> <h2>在scope2页面获取属性值</h2> page域的属性值:<%=pageContext.getAttribute("pageKey") %> <br> request域中属性值:<%=request.getAttribute("reqkey") %> <br> session域中属性值:<%=session.getAttribute("session") %> <br> application域中属性值:<%=application.getAttribute("application") %> </body>
<body>
<!--
EL全称：Expression Language，表达式语言
格式：${表达式}
作用：主要用来获取域对象中的属性值
EL表达式的查询规则：默认是全域查找
先从page域中开始查找，找到后直接返回，不再去其他域中查询，如果找不到再去requet域中查询，以此类推...
最后如果在application域中也找不到则返回空串
EL给我们提供了四个Scope对象，用来精确获取指定域中的属性值
pageScope
-获取page域中的属性值
requestScope
-获取request域中的属性值
sessionScope
-获取session域中的属性值
applicationScope
-获取application域中的属性值
-->
<%
Date date = new Date();
pageContext.setAttribute("date", date+"-");
request.setAttribute("date", date+"--");
session.setAttribute("date", date+"---");
application.setAttribute("date", date+"----");
//创建Employee对象
Employee emp = new Employee(1,"kk",new Department(1001,"设计部"));
//将emp返到page域中
pageContext.setAttribute("emp", emp);
%>
通过EL表达式输出当前的时间：${date }<br>
精确获取request域中的属性值：${requestScope.date }<br>
通过EL表达式输入Employee对象的lastName属性值：${emp.lastName }<br>
通过EL表达式输入Employee对象的dept属性的name属性值：${emp.dept.name }<br>
通过EL表达式获取getStatus方法的返回值：${emp.status }
</body>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!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>Ajax</title> <script type="text/javascript" src="${ pageContext.request.contextPath }/script/jquery-1.7.2.js"></script> <script type="text/javascript"> $(function(){ $("#btId").click(function(){ //通过$.ajax方法发送Ajax请求 $.ajax({ url:"${pageContext.request.contextPath}/AjaxServlet",//请求地址 type:"get", data:"username=admin&password=123", //设置请求参数 //响应成功系统会自动调用success该回调函数;响应数据会以参数的形式传入该函数 success:function(res){ //将相应数据设置到span标签中 $("#msg").text(res); }, dataType:"text" //设置响应类型,默认是text }); }); //1.给按钮绑定单击事件, $("#btId2").click(function(){ //2.通过$.get()/post()方法发送Ajax请求 var url = "${pageContext.request.contextPath}/AjaxServlet"; var params = "username=admin&password=123456"; alert(url); // /Web_Ajax/AjaxServlet $.get(url, params, function(res){ //将响应到的数据设置到span标签中 $("#msg2").html(res) }, "text"); }); }); </script> </head> <body> <button id="btId">Hello Ajax</button> <span style = "color: red" id="msg"></span> <br> <button id="btId2">Hello Ajax2</button> <span style = "color: red" id="msg2"></span> </body> </html> $.get/post(url, [data], [callback], [type]) url：必须的。用来设置请求地址 data：可选的。用来设置请求参数 callback：可选的。用来设置一个回调函数，响应成功之后系统会自动调用该函数， 响应数据会以参数的形式传入到该函数中 type：可选的。用来设置响应数据的类型，默认是text 后端--->>
* 处理Ajax请求的Servlet
public class AjaxServlet extends HttpServlet{ }
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { System.out.println("Get请求");
//获取用户名和密码； String username = request.getParameter("username"); String password = request.getParameter("password"); System.out.println("Get请求:" + username + "\t" + password); //给浏览器响应一个字符串
response.setContentType("text/html;charset=UTF-8"); response.getWriter().write(("Response success!")); }
右键Filter
Filter1.java
public class Filter1 implements Filter {
public Filter1() {
}
public void destroy() {
}
/**
* @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)
*/
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
System.out.println("1.1");
//放行请求
chain.doFilter(request, response);
System.out.println("1.2");//出去的代码
//如果两个都放行输出:1.1、2.1、Hello Filter、2.2、1.2
//把第一个过滤器关了,则输出:1.1、1.2 //后面的不会执行、2.1 Hello Filter、2.2
//把第二个过滤器关了,则输出:1.1 2.1 2.2 1.2
}
public void init(FilterConfig fConfig) throws ServletException {
}
}
loging.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!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>
<%
System.out.println("Hello Filter");
%>
<h2>Here</h2>
</body>
</html>
Filter2.java
public class Filter2 implements Filter {
public Filter2() {
}
public void destroy() {
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
System.out.println("2.1");
//chain.doFilter(request, response);
System.out.println("2.2");
}
public void init(FilterConfig fConfig) throws ServletException {
}
}
web.xml文件的配置：
<filter>
<display-name>Filter1</display-name>
<filter-name>Filter1</filter-name>
<filter-class>com.atguigu.filter.Filter1</filter-class>
</filter>
<filter-mapping>
<filter-name>Filter1</filter-name>
<url-pattern>/loging.jsp</url-pattern>
</filter-mapping>
<filter>
<display-name>Filter2</display-name>
<filter-name>Filter2</filter-name>
<filter-class>com.atguigu.filter.Filter2</filter-class>
</filter>
<filter-mapping>
<filter-name>Filter2</filter-name>
<url-pattern>/loging.jsp</url-pattern>
</filter-mapping>
</web-app>
1) Listener用于监听JavaWeb程序中的事件。
2) 例如：ServletContext、HttpSession、ServletRequest的创建、修改和删除。
3) 监听器的类型分为
① 生命周期
② 数据绑定
选择Lifecycle
import javax.servlet.http.HttpSessionActivationListener（这里边有两个方法，钝化和活化的时候）
import javax.servlet.http.HttpSessionBindingListener（它是放里边一个对象就会执行其方法）
这两个接口不需要在XML文件中注册，专门给javabean类去实现的
监听钝化（登录成功用户信息放到session中，session保存在服务器中，都是在内存里，一断电就都没了，钝化就是把session里的信息持久化到一个文件里边，当服务器关闭的时候session保存的信息会序列化到硬盘文件中）和活化（服务器读序列化的文件，从文件反序列化到内存中）的
<?xml version="1.0" encoding="UTF-8"?> <Student> <students id="1"> <sid>001</sid> <name>kris</name> <age>18</age> <gender>男</gender> <address>北京</address> </students> <students id="2"> <sid>002</sid> <name>smile</name> <age>18</age> <gender>女</gender> <address>海淀</address> </students> <students id="3"> <sid>003</sid> <name>嘿嘿</name> <age>20</age> <gender>男</gender> <address>朝阳</address> </students> </Student>
package com.atguigu.test; import java.util.List; import org.dom4j.Document; import org.dom4j.DocumentException; import org.dom4j.Element; import org.dom4j.io.SAXReader; import com.atguigu.bean.Student; public class TestDom4j { public static void main(String[] args) throws DocumentException { //1创建解析器对象 SAXReader saxReader = new SAXReader(); //2解析xml文件得到Document对象; Document doc = saxReader.read("student.xml"); System.out.println(doc); //3获取根元素 Element rootEle = doc.getRootElement(); //4解析所有的student元素 List<Element> stus = rootEle.elements("students"); System.out.println(stus); //5遍历得到每一个student标签; for (Element ele : stus) { //获取id属性值 String id = ele.attributeValue("id"); //获取的是根元素的id System.out.println(id); // Element nameEle = ele.element("name"); System.out.println("每个element的名字:" + nameEle.getText()); String sid = ele.elementText("sid"); String name = ele.elementText("name"); String age = ele.elementText("age"); String gender = ele.elementText("gender"); String address = ele.elementText("address"); System.out.println(sid + "\t" + name + "\t" + age + "\t" + gender + "\t" + address); Student student = new Student(sid, name, age, gender, address); System.out.println(student); } } } package com.atguigu.bean; public class Student { private String sid; private String name; private String age; private String gender; private String address; public Student() { super(); } public Student(String sid, String name, String age, String gender, String address) { super(); this.sid = sid; this.name = name; this.age = age; this.gender = gender; this.address = address; } public String getSid() { return sid; } public void setSid(String sid) { this.sid = sid; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getAge() { return age; } public void setAge(String age) { this.age = age; } public String getGender() { return gender; } public void setGender(String gender) { this.gender = gender; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } @Override public String toString() { return "Student [sid=" + sid + ", name=" + name + ", age=" + age + ", gender=" + gender + ", address=" + address + "]"; } }
对象和JSON字符串之间的互相转换导gson-2.2.4.jar包
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<script type="text/javascript" src="script/jquery-1.7.2.js"></script>
<script type="text/javascript">
//1.JSON对象
var jsonObj = {"name": "kk", "age":20};
//alert(jsonObj); //[object Object]
//2.JSON数组 //获取数组中JSON对象的age属性值
var jsonArray = ["哈哈", 100, true, null, jsonObj]
//alert(jsonArray) //哈哈,100,true,,[object Object]
//alert(jsonArray[4].age) //20
//3.复杂点的
var json = {
"name":"唐僧",
"age":"20",
"sons":[
{"name": "悟空"},
{"name": "八戒", "wives":[
{"name": "嫦娥", "age": 19},
{"name": "白狐", "age": 18}
]}
]
}
alert(json.sons[1].wives[1].age) //18
//前端中 两种互相的转换 --> 1.将JSON对象转换成JSON字符串
var objToStr = JSON.stringify(jsonObj);
alert(objToStr); //{"name":"kk","age":20}
//2.将JSON字符串转成JSON对象
var jsonStr = ‘{"name": "smile", "age": 20}‘;
var strToObj = JSON.parse(jsonStr);
alert(strToObj.name); //[object Object] --> smile
//-->前端响应后端传来的JSON数据;
$(function(){
//绑定单击事件
$("#btId").click(function(){
var url = "JSONServlet"; //设置请求地址
//发送ajax请求
$.post(url, function(res){
alert(res.id + "-" + res.name + "-" + res.age)
}, "json"); //接收响应的json数据
});
});
</script>
</head>
<body>
<button id="btId">Ajax请求接收JSON格式的响应数据</button>
</body>
</html>
/**
* 响应JSON数据的Servlet
*/
public class JSONServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
System.out.println("-------------");
User user = new User(1, "kk", 20); //假设从数据库中查询出来一个User对象
//创建Gson对象
Gson gson = new Gson();
//①将User对象转换成JSON字符串
String jsonStr = gson.toJson(user); //jsonStr字符串
System.out.println("转成jsonStr字符串:" + jsonStr);
//②将JSON字符串转成JSON对象
User fromJson = gson.fromJson(jsonStr, User.class);
//给前台响应一个字符串
response.setContentType("text/html;charset=UTF-8");
response.getWriter().write(jsonStr); //字符串
}
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
}
标签：tomcat xsd 子接口 pass inter 在服务器 llb ESS 个数
原文地址：https://www.cnblogs.com/shengyang17/p/10184135.html
