javaweb二

除了servlet规范,还有filter,listener。filter和servlet相似,但是在servlet之前执行,主要区别是有一个FilterChain接口可以执行拦截方法。

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.annotation.WebFilter;
/*Filter和Servlet结构相似,有两个生命周期方法和一个执行任务的方法,且配置格式相同
 * 注意url的不同,Filter的url是要拦截的url,而Servlet的url是访问时使用的url
 * 当用户访问相应的url路径时,会执行Filter的doFilter()
 * 
 * 注意:下面的@WebFilter部分是Servlet3的新特性,是过滤器的注解,不需要在web.xml进行配置,简化的配置文件信息
 */
@WebFilter({ "/BFilter", "/AServlet" })
public class AFilter implements Filter {

    /*这里的参数FilterConfig对象和ServletConfig相似
     */
    public void destroy() {
        System.out.println("A拦截器死亡");
    }

    /*下面的参数FilterChain对象只有一个方法doFilter(),
     * 该方法可以执行目标资源(即被拦截的资源),也可以执行下一个拦截器(如果有的话,像一条链一样)
     */
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        System.out.println("A成功拦截");
        chain.doFilter(request, response);    //执行这句话就可以执行被拦截的url要进行的操作
        System.out.println("A执行完上面在回来");
    }

    public void init(FilterConfig fConfig) throws ServletException {
        System.out.println("hahahah...,A拦截器出生");
    }

}

listener和它们稍有不同,是对特定事件的监听和处理。

import javax.servlet.ServletContextAttributeEvent;
import javax.servlet.ServletContextAttributeListener;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionBindingListener;

/*listener监听器也是Javaweb三大组件之一,也需要在web.xml中进行配置
 * 监听器就是用来对特定事件进行监听,并作出相应的行为,所以监听器都是接口,需要用户自己完成对行为的定义
 * Javaweb中有8个监听器,其中有6个对3大域(ServletContext/HttpSession/ServletResquset)进行监听,
 * 其中一个监听域的生命周期,一个监听域的属性
 * 只要实现相应接口即可完成监听,下面就是对ServletContext生命周期的监听(即对init()和destroy()监听)
 */
@WebListener
public class Dlistener implements ServletContextListener, ServletContextAttributeListener,HttpSessionBindingListener{
    public Dlistener() {
    }

    /*监听器的另一个重要的方面就是事件对象,这是自动传入的,可以对事件进行分析然后采取不同的处理方式
     * 在生命周期监听器中,事件对象的主要方法是获取相应域对象
     */
    @Override
    public void contextDestroyed(ServletContextEvent arg0) {
        System.out.println("死亡！");
    }

    @Override
    public void contextInitialized(ServletContextEvent arg0) {
        System.out.println("出生！");
    }


    /*属性监听器:用于对属性的设置/重置/移除等事件的监听，
     * 这种监听器的事件对象可以获取操作的属性的键值对,
     */
    public void attributeAdded(ServletContextAttributeEvent event)  { 
        System.out.println("您向application中添加了一个名为" + event.getName() + ", 值为："
                + event.getValue() + "的属性");
    }

    //注意重置时,事件对象获取的是被操作的属性键值对(即原来的),同时可以通过域对象获取新的键值对
    public void attributeReplaced(ServletContextAttributeEvent event)  { 
        System.out.println(event.getName() + "=" + event.getValue() + ", "
                + event.getServletContext().getAttribute(event.getName()));
    }
    
    public void attributeRemoved(ServletContextAttributeEvent event)  { 
        System.out.println(event.getName() + "=" + event.getValue());
    }
    
    /*8个监听器还有两个,可称为感知监听器,都与HttpSession有关
     * 特点是：1、添加在javabean中而非域中，2、不需在web.xml中配置
     * 
     * 一个是HttpSessionBindingListener,绑定在一个JavaBean中,可以使其感知是否被session添加/移除
     * 另一个是HttpSessionActivationListener,同样绑定在JavaBean中,可以感知是否绑定session并且这个
     * session是否钝化或重新活化
     */
    private String username;
    private String password;
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    
    public Dlistener(String username, String password) {
        super();
        this.username = username;
        this.password = password;
    }
    @Override
    public String toString() {
        return "User [username=" + username + ", password=" + password + "]";
    }
    
        //下面两个是HttpSessionBindingListener监听器方法,感应该javabean是否被session保存和移除
    @Override
    public void valueBound(HttpSessionBindingEvent event) {
        System.out.println("啊~，session添加了我！");
    }
    @Override
    public void valueUnbound(HttpSessionBindingEvent event) {
        System.out.println("哇哇哇~，无情的session抛弃了我！");
    }
}

JSP是Java server pages,是java的view层即响应的基础,=html+Java代码+Java指令,

在第一次访问JSP文件时,服务器会将其转换为Java文件,并编译为class字节码文件,然后创建对象。这个对象内部会生成一些对象,包括域对象;也会对java指令进行解释执行,并且对参数进行赋值,最后将执行之后的html代码相应给客户端。

Java指令,包括三种:

　　1、page指令，是对文件的全局设置,比如响应的编码等<%@page ...%>

　　2、include指令，静态包含引入文件，<%@include ...%>

　　3、taglib,导入标签库.最基础使用的是JSTL和fmt标签库。其中JSTL标签库是重点:可以进行判断,循环等复杂逻辑。注意:使用JSTL标签库需要导入相应jar包,myeclipse中已经默认添加,所以可以直接使用。　　　

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%--
    这里使用的是JSTL的核心库标签:core，也被称为c标签,前缀通常使用c 
--%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
    这里使用的是JSTL的格式化标签库:fmt， 
--%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    
    <title>My JSP 'JSTL.jsp' starting page</title>
    
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">    
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
    <!--
    <link rel="stylesheet" type="text/css" href="styles.css">
    -->

  </head>
  
  <body>
      <%--下面三个标签是用于设置/输出/移除域中属性,可以设置指定域,设置时默认对特殊标签进行转义,默认域为page--%>
    <c:set var="xxx" value="<script>alter('hello');</script>" scope="page"/>
    <c:out value="${xxx}" /><br/>
    <c:remove var="xxx" scope="page"/>
    <c:out value="${xxx}" default="该值不存在或已被删除"/><br/>
    
    <%--下面是两种生成url的方式比较 --%>
    ${pageContext.request.contextPath}/Aservlet<br/>
    <c:url value="/AServlet">
        <c:param name="username" value="张三"></c:param>
    </c:url>
    <br/>
    
    <%--JSTL标签还可以替换判断语句和循环语,
        判断语句分两种:1、单个判断，2、多个判断
    --%>
    <%--
        注意:判断是否为空时,格式为not empty ***/empty ***
     --%>
    <c:if test="${not empty xxx}">
        hello<br/>
    </c:if>
    <c:set var="fen" value="60" />
    <c:choose>
        <c:when test="${fen>100||fen<0}">
            错误的分数<br/>
        </c:when>
        <c:when test="${fen<60}">
            不及格<br/>
        </c:when>
        <c:when test="${fen>=60}">
            及格<br/>
        </c:when>
    </c:choose>
    <%--循环有两种,一种是计数循环;一种是遍历循环,用于集合和数组 --%>
    <c:forEach var="i" begin="1" end="10" step="2">
        ${i}<br/>
    </c:forEach>
    <%
        String[] str={"a","b"};
        request.setAttribute("str", str);
    %>
    <%--！！！注意下面在items属性值的结束"之前不要有多余的空格,否则会出错--%>
    <c:forEach items="${requestScope.str}" var="string">
        ${string}<br/>
    </c:forEach>
    
    <%
        Date d=new Date();
        request.setAttribute("date",d);
    %>
    <fmt:formatDate value="${date}" pattern="yyyy-MM-dd HH:mm:ss"/>
    <br/>
  </body>
</html>

　　　　参考:http://www.cnblogs.com/lihuiyy/archive/2012/02/24/2366806.html

java代码是在jsp中运行java程序片段,但是不建议过多使用。

在jsp页面和java代码之间传递数据使用的是四大域对象,在代码中通常通过HttpRequestServlet来获取其他几个域对象,而且这个除了是请求对象本身就是Request域对象，参考:http://www.cnblogs.com/jbelial/archive/2013/07/11/3184928.html。

JavaBean就是一个满足特殊规范的类:(最早用于创建图形化界面时拖拽控件时使用,一个控件对应一个JavaBean类)

参考：http://davidgjy.iteye.com/blog/442749

public class Person {
    /*该类就是一个javabean的示例,规范是:
     * javaBean的规范：
       * 1. 必须要有一个默认构造器
     * 2. 提供get/set方法，如果只有get方法，那么这个属性是只读属性！
     * 3. 属性：有get/set方法的成员，还可以没有成员，只有get/set方法。属性名称由get/set方法来决定！而不是成员名称！
       * 4. 方法名称满足一定的规范，那么它就是属性！boolean类型的属性，它的读方法可以是is开头，也可以是get开头！
     * 
     */
    private String username;
    private int age;
    private String sex;
    
    public Person(String username, int age, String sex) {
        super();
        this.username = username;
        this.age = age;
        this.sex = sex;
    }
    public Person() {
        super();
    }
    
    //第三条指的是如下面的情况:get后面使用的name，而成员是username时以get后为准,
    public String getName() {
        return username;
    }
    public void setName(String username) {
        this.username = username;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    //一个属性可以只有get/set方法而没有成员
    public String getId(){
        return "89757";
    }
    
    @Override
    public String toString() {
        return "Person [username=" + username + ", age=" + age + ", sex=" + sex + "]";
    }
    
}

操作JavaBean可以使用内省,内省是基于反射的一种实现,可以获取beaninfo(其中包含对应Javabean的信息),操作流程如下

　　内省类 --> Bean信息 --> 属性描述符 --> 属性的get/set对应的Method！ --- > 可以反射了！

但是apache提供了一个jar包,可以方便的实现上述操作

import java.util.HashMap;
import java.util.Map;

import org.apache.commons.beanutils.BeanUtils;
import org.junit.Test;

import cn.dqxst.utils.CommonUtils;

public class BeanUtilsDemo {
    /*在myeclipse中使用junit单元测试,
     * 只要在需要测试的前加   @Test ,注意有大小写区别,就会提示导入测试所需的包
     */
    @Test
    public void fun1() throws Exception {
        String className="cn.dqxst.domain.Person";
        Class<?> clazz=Class.forName(className);
        Object bean=clazz.newInstance();
        //BeanUtils可以代替繁琐的反省操作,直接对JavaBean操作
        /*如果某个属性没有设置不会报错,
         * 注意该类对属性值的处理:都会转换为字符串,然后在赋值时按需要进行转换
         * 并且在获取属性时,会将其值转换为String类型,可以按需转换
         */
        BeanUtils.setProperty(bean, "name", "张三");
        BeanUtils.setProperty(bean, "age", "23");
        //如果有多余属性设置则忽略
        BeanUtils.setProperty(bean, "xxx", "XXX");
        
        System.out.println(bean);
    }
    
    //将一个Map和一个JavaBean对应,两者包含相同的属性
    @Test
    public void fun2() throws Exception{
        Map<String,String> map=new HashMap<String, String>();
        map.put("name","张三");
        map.put("password", "123");
        
        User user=new User();
        BeanUtils.populate(user, map);
        
        System.out.println(user);
    }
        //这里是使用再次封装的类进行上述操作
    @Test
    public void fun3(){
        Map<String,String> map=new HashMap<String, String>();
        map.put("name","张三");
        map.put("password", "123");
        
        User user=CommonUtils.toBean(map, User.class);
        System.out.println(user);
    }

}

import java.util.Map;
import java.util.UUID;

import org.apache.commons.beanutils.BeanUtils;

public class CommonUtils {
    //获取一个32位长的随机大写字串
    public static String uuid(){
        return UUID.randomUUID().toString().replace("-", "").toUpperCase();
    }
    
    //将一个Map集合中的数据封装到一个JavaBean中,两者需要一一对应
    public static <T> T toBean(Map<String,String> map,Class<T> clazz){
        //1、在这里使用try,避免调用者进行重复的错误处理过程
        try{
            //创建指定类型的JavaBean对象
            T bean=clazz.newInstance();
            //调用BeanUtils类进行封装操作
            BeanUtils.populate(bean, map);
            //返回封装好的JavaBean对象
            return bean;
        }catch(Exception e){
            throw new RuntimeException();
        }
    }
}