JavaEE

JavaEE

基础

• JavaEE处理机制
  1. 前端发出请求（浏览器）
     • url重定向：<a>，location.href，open()，F5刷新（只支持GET请求）
     • form表单请求：<form>，支持文件上传（支持GET、POST请求）
     • Ajax请求：异步请求，页面不刷新（支持GET、POST请求）
  2. web服务接收（监听器）并解析
     • Request对象（HttpServletRequest），请求的全部内容
     • Response对象（回应对象），写入结果
     • Context对象（上下文），指定应用相关信息
  3. 指定应用程序处理
     web.xml等配置文件
  4. 应用指定处理代码
     地址解析，通过地址指定位置
  5. 读取请求，处理业务
     获取request对象，增删改查
  6. 回应处理结果
     • html页面渲染
     • 将结果写入response对象（能被浏览器识别的内容）
  7. 浏览器解析回应内容，进行显示处理
     接收到response对象的http数据，处理
• 前端脚本：能够被浏览器识别处理的脚本，html，css，JavaScript（在java当中看作字符串处理）
• 后端脚本：服务端脚本，能够被服务器处理的脚本，java，php，c#.net
• 静态页面：全部为前端脚本的页面文件
• 动态页面：通过后端脚本执行完成的页面文件

web服务器

tomcat（线程阻塞）
nginx（线程非阻塞）

1. 端口监听（进程监听）
   接收网络请求
2. http解析
   把请求转为对象，翻译协议内容
3. 应用容器
   多个站点（放置多个网站）

• tomcat服务器
  1. 安装开发配置
     • 两种安装方法：
       • 安装版：下一步，端口冲突
       • 解压版：绿色开发，不适合实施
     • 开发设置：
       • eclipse-window-属性-server-runtime env，按钮add，选择版本，设置路径+jdk，保存（注意：环境只需一套）
       • window-show view-server窗口，点击窗口超链，自动创建servers项目（当前应用容器配置项目）
  2. 设置
     • web.xml
     • server.xml
       • 端口号：默认（8080）
       • 发布目录：webapps
       • 日志目录：logs
  3. 目录
     基础目录（不可删）
     • bin：命令目录
       tomcat-juli.jar：myeclipse设置时需要
       starup.bat：绿色版启动服务
       tomcat.exe（安装版拥有）：窗口启动服务
     • conf：配置文件
     • lib：开发支持库
     • logs：日志
       发布运行站点时自动生成（可删除）
     • work：运行时的编译文件，jsp所生成的java.class文件
     • webapps：发布路径
       ROOT文件夹：默认站点发布路径，url不需站点名称
  4. 缓存清理
     1. 清理项目缓存，eclipse：project-clean，（不清理导致执行结果和未改前一样）
     2. 浏览器缓存，前端缓存：清空浏览器历史记录，（针对css和js文件，无刷新）
     3. web缓存，tomcat发布缓存：servers-clean，文件夹删除，（启动tomcat时，自动加载全部站点，启动速度慢，启动错项目，异常联动）
        方法：删除servers项目，删除发布路径
  5. 新站点
     • 创建：dynamic project，必须设置server runtime
     • 目录：
       • java resource/src：Java代码位置
       • webContent：站点根目录（放置页面，css，js）
         • /META-INF：站点签名（一般不用）
         • /WEB-INF：配置文件夹，不能网站访问
           /lib：额外jar包，自动引用
           /web.xml：项目配置文件

jsp页面

• 动态页面

  • 编译指令集

    1. @page：当前页面（类）描述

       <%@page import="java.util.List"%>
       <%@ page language="java" contentType="text/html; charset=utf-8"
           pageEncoding="utf-8" isELIgnored="false" isErrorPage="false"%>
           isELIgnored：EL表达式支持
           isErrorPage：异常处理也
       

    2. @include 静态引入（生成java文件时导入）

       <%@include file="a.jsp"%> 
       

    3. @taglib 导入后台标签库

       <%@taglib prefix="c" uri=""%>
       c：标签库别名
       uri：位置标识
       

  • 静态脚本

  • 用法

    1. <% java代码 %> 执行java代
    2. <%=变量%> 输出java变量值
• 行为标签

  1. 动态引入（执行时导入）jsp:include

     <jsp:include page="a.jsp"></jsp:include>
     

  2. 请求转发：jsp:forward

     <jsp:forward page="a.jsp"></jsp:forward>
     

• 内置对象

  1. 输出：out
     out.write(i+"<br>");

  2. 请求对象：request

     request.getParameter("count")；	//获取请求参数
     request.setAttribute(arg0, arg1);		//设置request服务器变量
     request.getAttribute(arg0);		//获取变量
     

  3. 回应对象：response

     response.setContentType(“text/html;charset='utf-8'”);	//告诉浏览器
     response.getWriter().write("1234");
     

  4. 会话对象：session

     • 时效性：自创建开始，指定失效时间（相对于上次会话访问）

     • 功能：记录会话信息（连接会话，自动生成会话id），与其他会话定义的变量不能互访

     • 使用：

       HttpSession s = request.getSession();
       		s.getId();	//会话id，自动创建，会话标识
       		s.getCreationTime();	//创建时间
       		s.getLastAccessedTime();	//最后激活时间
       		s.setMaxInactiveInterval(10); 	//秒数
       		s.setAttribute("user", "admin");
       
       ${pageContext.session.id}	//会话id
       ${sessionScope.user}	//值使用
       

  5. 应用对象：application

     • 时效：与web服务器同效
     • 功能：每个会话都能访问同一个，查询结果缓存，通用设置
     • 使用：与requestScope一样，改为${applicationScope }
       request.getServletContext().setAttribute("list", list);

  6. jsp页的this：page（忽略）

  7. 页面上下文：pageContext

  8. 页面配置信息：config，在web.xml设置

servlet

• 创建使用

  通常使用方法，javaee 3.0以上版本
  @WebServlet("/TesetServlet")	//访问地址，一个项目地位唯一，否则报异常
  public class TesetServlet extends HttpServlet {	//继承
  	//如果为GET请求进入doGet方法
  	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  		//回应输出
  		response.getWriter().append("Served at: ").append(request.getContextPath());
  	}
  	//如果为POST请求进入doPost方法
  	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  		doGet(request, response);
  	}
  }
  

  	@WebServlet("/lhy")
  //servlet处理的核心
  public abstract class TesetServlet extends GenericServlet {
  
  	@Override
  	public void service(ServletRequest req, ServletResponse resp) throws ServletException, IOException {
  		//请求已进入先执行
  		HttpServletRequest req1 = (HttpServletRequest) req;
  		HttpServletResponse resp1 = (HttpServletResponse) resp;
  		String m = req1.getMethod();
  		if(m.equalsIgnoreCase("get")) {
  			doget(req1,resp1);
  		}
  	}
  
  	protected abstract void doget(HttpServletRequest req1, HttpServletResponse resq1);
  	
  }
  
  
  

  • 通过web.xml设置，指定访问地址

    <servlet>
    		<servlet-name>aaa</servlet-name>
    		<servlet-class>servlet.Servlet</servlet-class>	//类全名（包+类名）
    	</servlet>
    	<servlet-mapping>
    		<servlet-name>aaa</servlet-name>
    		<url-pattern>/bb</url-pattern>
    	</servlet-mapping>
    

    //	编写servlet定义类
    public class Servlet extends HttpServlet {
    			@Override
    			protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    				resp.getWriter().append("<a href='#'>林海洋</a>");
    			}
    		}
    

• 其他内容

  • MVC

• 回应方式

  1. 直接输出html
     response.getWriter().append("html内容");
  2. 后端url重定向
     response.sendRedirect("a.jsp");
  3. 直接输出json串（用于Ajax，可通过Jackson自动生成）
     response.getWriter().append("json字符串");
  4. 请求转发（可以中途加入数据）
     request.getRequestDispatcher("index.jsp").include(request, response);
     forward方法：替代之前全部输出；
     include方法：在之前输出的结果中附加
  5. 使用前端模板引擎，freemark

• JSTL+EL 全面替代jsp脚本

  1. jstl Java通用标准库
     • core库：核心库

       • <c:foreach>：循环
         varStatus：指定变量名称，作为行状态对象使用，index，count属性
         var：指定变量名称，作为循环的个体
         items：循环的内容，用EL表达式

         <c:foreach items="${list}" var="row" varStatus="v">
         	<tr>
         		<td>${v.index}</td>
         		<td>${row.name}</td>
         	</tr>
         </c:foreach>
         

       • <c:if>：判断处理，没有else，内容是EL的Boolean表达式

         <c:if test="${v.index%2==0 && v.count>10}"></c:if>
         

       • <c:set>：设置变量值

         <c:set target="${row}" property="name" value="123"></c:set>
         

       • <c:redirect>：url重定向

         <c:redirect url="a.jsp"></c:redirect>
         

     • functions：函数库
     • sql：数据处理库
     • xml库
     • fmt：地域处理库
  2. EL表达式（数据读取器）：只有语法错误时报异常

     • 用法：${ }

       <%@ page language="java" contentType="text/html; charset=utf-8"
       	pageEncoding="utf-8" isELIgnored="false"%>
       

     • 内部访问对象

       • requestScope：访问服务器值request，可省略

         request.setAttribute("list",list);
         request.getAttribute("list");
         

       • sessionScope：服务器值session
         request.getSession().setAttribute(arg0,arg1);

       • applicationScope：服务器值application
         request.getServletContext().setAttribute(arg0, arg1);

       • pageScope：当前页变量，可省略

       • param：参数值获取
         request.getParameter(arg0);

       • paramValues：同名参数获取

         ${paramsValues.count[1]}
         request.getParameterValues(arg0);
         

       • header：http协议头数据

         request.getHeader(arg0);
         		response.addHeader(arg0, arg1);
         

       • headerValues
         request.getHeaderNames();

       • cookie：客户端临时存储数据
         加入value是取值，否则获取cookie对象

         ${cookie.usename.value}
         request.getCookies();
         response.addCookie(arg0);
         

       • pageContext：当前页上下文的获取

         ${pageContext.request.queryString}//获取url地址参数
         request.getServletContext();
         

       • initParam：当前web.xml设置变量

         <context-param>
         		<param-name>bbb</param-name>
         		<param-value>111</param-value>
         </context-param>
         

         ${initParam.name}
         request.getServletContext.getInitParameter(arg0):
         //获取servlet内定义
         在servlet内：this.getInitParameter(name);
         

• cookie

  • 与session的区别：

    1. 缓存：
       session服务器变量，
       cookie客户端变量，存在浏览器缓存
    2. 时间：
       session：相对时间（上次激活）移除
       cookie：绝对时间，浏览器自动删除
    3. 区域：
       session：站内全部有效
       cookie：站内指定范围有效

  • 每次发送请求时，将范围内的cookie全部塞入请求一起发送

  • 使用

    Cookie[] cs = request.getCookies();	//获取，一般不用
    		Cookie c = new Cookie("name", request.getParameter("name"));
    		c.setDomain("主机");
    		c.setPath("路径");
    		c.setMaxAge(3600*24*100); 	//秒数
    		c.setVersion(2); 	//版本，替换
    		response.addCookie(c);
    

  • session会话跟踪 JSESSIONID=XXX

    1. cookie会话记忆
    2. url会话跟踪（有些浏览器禁止cookie）
       a.jsp;jsessionid=5AC6268DD8D4D5D1FDF5D41E9F2FD960

• 总结：

  1. <a> <form>发送请求
  2. jsp或servlet接受请求
  3. 业务处理，增删改查
  4. 请求转发回应
  5. 全部访问入口为servlet

listener监听器

• 服务状态：启动，停止；网站数据初始化

  @WebListener	//可使用注解替代web.xml中<listener>的设置
  public class webListener implements ServletContextListener {
  	@Override
  	public void contextDestroyed(ServletContextEvent arg0) {
  		
  	}
  	@Override
  	public void contextInitialized(ServletContextEvent scv) {
  		scv.getServletContext().setAttribute(arg0, arg1);	//application
  		scv.getServletContext().getInitParameter(arg0);	//获取<context-param>的值
  		System.out.println("web启动了");
  	}
  }
  

  //web.xml
  <listener>
  		<listener-class>listener.webListener</listener-class>
  	</listener>
  

• 会话状态

  public class sessionListener implements HttpSessionListener {
  	int pos = 0;
  	@Override
  	public void sessionCreated(HttpSessionEvent hse) {
  		System.out.println("sessionCreated:"+hse.getSession().getId());
  		System.out.println("人数："+(++pos));
  	}
  	@Override
  	public void sessionDestroyed(HttpSessionEvent arg0) {
  		System.out.println("---人数："+(--pos));
  	}
  }
  

  //web.xml
  <listener>
  		<listener-class>listener.sessionListener</listener-class>
  	</listener>
  

• 请求属性

  public class requestListener implements ServletRequestAttributeListener {
  	@Override
  	public void attributeAdded(ServletRequestAttributeEvent sae) {
  		System.out.println(sae.getName());
  		sae.getServletRequest().setAttribute(arg0, arg1);
  	}
  	@Override
  	public void attributeRemoved(ServletRequestAttributeEvent arg0) {
  	}
  	@Override
  	public void attributeReplaced(ServletRequestAttributeEvent arg0) {
  	}  
  }
  

  //web.xml
  	<listener>
  		<listener-class>listener.requestListener</listener-class>
  	</listener>
  

filter：请求过滤器

• 基本用法：

  1. 注解

     @WebFilter(urlPatterns="/booktype/*")
     public class testFilter implements Filter {
     	@Override
     	public void destroy() {	
     	}
     	@Override
     	public void doFilter(ServletRequest arg0, ServletResponse arg1, FilterChain fc)
     			throws IOException, ServletException {
     		HttpServletRequest req = (HttpServletRequest) arg0;
     		System.out.println(req.getRequestURI());
     		//请求接收前
     		fc.doFilter(arg0, arg1); 	//继续请求，执行代码
     		//处理代码后
     	}
     	@Override
     	public void init(FilterConfig arg0) throws ServletException {
     	}
     }
     

  2. web.xml

     <filter>
      		<filter-name>qq</filter-name>
      		<filter-class>filter.testFilter</filter-class>
      	</filter>
      	<filter-mapping>
      		<filter-name>qq</filter-name>
      		<url-pattern>/booktype/*</url-pattern>
      	</filter-mapping>
     

加密

• MD5加密：（非可逆），改动字符，保障安全
• desc加密：（可逆），必须提供Key（8位）
• base64编码：（字符序列化）将任何数据转为字符串，并且可以转回来

验证码生成

1. 内存当中生成绘图区域
2. 随机数据，绘制到区域
3. 图片生成字节数组
4. 在response中写入字节数组
5. 在session中记录随机字符

文件上传

• 前端

  <form action="fileupload" method="post" enctype="multipart/form-data">
  	<input type="file" name="file">
  	<input type="submit">
  </form>
  

• 后端：commonds-fileupload jar插件

• 获取服务器绝对路径：
  String filepath = req.getSession().getServletContext().getRealPath("upload");

• 生成一个128位长的全球唯一标识
  UUID randomUUID = UUID.randomUUID();

请求状态号

1. 200：一切成功
2. 302、304：从浏览器缓存处理，未发出请求（未发出客户端）
3. 404：发出请求，没有找到目标处理代码
4. 406：发出请求，请求被中断，拦截器
5. 500：服务器代码处理异常

web.xml

• <welcome>，<servlet>，<listener>，<filter>，<init-param>，<context-param>

• <jsp-config></jsp-config> jsp通用设置

• <error-page></error-page> 错误页处理

  <error-page>
   		<error-code>404</error-code>
   		<location>/error404.html</location>
   	</error-page>
  

• <session-config> session会话时间设置

  <session-config>
   		<session-timeout>300</session-timeout>
   	</session-config>
  

Java tag：自定义标签

• 标签类

  1. 继承：public class MyTag extends TagSupport

  2. 创建属性：定义属性+getters+setters

  3. 重写方法：doStartTag、doEndTag、doAfterBody

     public int doStartTag() throws JspException {
     		JspWriter out = this.pageContext.getOut();
     		out.write("<a href='"+href+"'>"+name+"</a>");
     		return TagSupport.EVAL_PAGE;
     	}
     

  4. 返回值：TagSupport

     1. SKIP_BODY 表示不用处理标签体，直接调用doEndTag()方法。
     2. SKIP_PAGE 忽略标签后面的JSP内容。
     3. EVAL_PAGE 处理标签后，继续处理JSP后面的内容。
     4. EVAL_BODY_BUFFERED 表示需要处理标签体。
     5. EVAL_BODY_INCLUDE 表示需要处理标签体
     6. EVAL_BODY_AGAIN 对标签体循环处理

• 标签设置文件

  在WEB_INF内创建tld文件
  <?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
          "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
  <taglib>
   <tlib-version>1.1.2</tlib-version>
      <jsp-version>1.2</jsp-version>
      <short-name>wjx</short-name>  <!--标签的短名称（可以随意取） -->
      <uri>/WEB-INF/tag</uri> <!--位置，用于引用 -->
     <tag>
        <name>a</name>
        <tag-class>tag.MyTag</tag-class>
         <attribute>
         		<name>name</name>
         		<required>true</required>      //必须录入
         		<type>java.lang.String</type>
                     <rtexprvalue>false</rtexprvalue>      <!--是否可用el表达式-->
                    <body-content>JSP</body-content>
           <!--empty表示标签体内容可以为空，jsp则表示标签体内放置jsp页面元素 -->
        </attribute>
     </tag>
  </taglib>
  

• 使用

  <%@taglib prefix="my"  uri="/WEB-INF/tag"%>
  <my:a href="http://www.baidu.com" name="百度"></my:a>   
  

annotation

• 创建

  @Documented
  @Target({ElementType.FIELD,ElementType.TYPE})
  @Retention(RetentionPolicy.RUNTIME)
  public @interface Myannotation {
  	String value();
  	int count() default 1;
  }                         
                             @Target(ElementType.TYPE) //接口、类、枚举、注解 
  　　　　　　　　@Target(ElementType.FIELD) //字段、枚举的常量 
  　　　　　　　　@Target(ElementType.METHOD) //方法 
  　　　　　　　　@Target(ElementType.PARAMETER) //方法参数 
  　　　　　　　　@Target(ElementType.CONSTRUCTOR) //构造函数 
  　　　　　　　　@Target(ElementType.LOCAL_VARIABLE)//局部变量 
  　　　　　　　　@Target(ElementType.ANNOTATION_TYPE)//注解 
  　　　　　　　　@Target(ElementType.PACKAGE) ///包
  

• 使用：使用反射获取处理

  使用反射获取处理
  @Myannotation(value="abc",count=3)
  	String name;
  
  处理
                 Field[] fs=this.getClass().getDeclaredFields();
  		for(Field f:fs) {
  			Myannotation a=f.getAnnotation(Myannotation.class);
  			String aa="";
  			for(int i=0;i<a.count();i++) {
  				aa+=a.value();
  			}
  				f.set(this, aa);
  		}
  

web service

异构架通讯，跨域，跨系统

• 架构

  1. SOA：面向服务架构
  2. SOAP：简单对象访问协议，xml通讯协议
  3. RESTful：接口式开发，json通讯标准
  4. PRC：远程过程调用
  5. RMI：远程方法调用

• 服务端

  1. 创建类，加入@WebService注解
  2. 创建public方法：对外提供
  3. 启动服务端

  @WebService
  public class testService {
  	public void getStr(String name) {
  		System.out.println("you name is:"+name);
  	}
  	public static void main(String[] args) {
  	 Endpoint.publish("http://127.0.0.1:9091/Service/test", new testService());
  	     System.out.println("service success !");
  	}
  }
  

• 客户端
  通过地址生成客户端依赖
  使用jdk wsimport命令
  改变当前文件夹到现项目的src文件夹

  wsimport -p client -keep  http://localhost:9091/Service/myservice?wsdl
  源码
  public static void main(String[] args) {
  //		 TestService sayHello = new TestServiceService().getTestServicePort();
  //         sayHello.getStr("sfsfs");
  		try {
          URL url = new URL("http://127.0.0.1:9091/Service/test?wsdl");
          QName qname = new QName("http://server/", "testServiceService");
          Service service = Service.create(url, qname);
          TestService sayHello = service.getPort(TestService.class);
          sayHello.getStr("孙菲菲");
      } catch (Exception e) {
          e.printStackTrace();
      }