JavaWeb基础

servlet程序的在web.xml中的配置

    <!--servlet标签给tomcat配置servlet程序-->
    <servlet>
        <!--servlet-name标签给servlet程序起一个别名-->
        <servlet-name>HelloServlet</servlet-name>
        <!--servlet-class 标签是servlet程序的全类名 -->
        <servlet-class>com.learn.servlet.HelloServlet</servlet-class>
         <!--配置初始化参数 键值对-->
        <init-param>
            <!--键-->
            <param-name>username</param-name>
            <!--值-->
            <param-value>root</param-value>
        </init-param>
    </servlet>
    <!--servlet-mapping标签给servlet标签配置访问地址-->
    <servlet-mapping>
        <!--此servlet-name标签的作用是告诉服务器配置 的地址给哪个servlet程序使用-->
        <servlet-name>HelloServlet</servlet-name>
        <!--url-pattern标签配置访问地址-->
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

ServletConfig类的作用

public void init(ServletConfig servletConfig) throws ServletException {
        //获取servlet程序的别名
        System.out.println(servletConfig.getServletName());
        //获取初始化参数
        System.out.println(servletConfig.getInitParameter("username"));
        //获取servletContext对象
        System.out.println(servletConfig.getServletContext());
    }

servletContext类的作用

    1：一个web工程 只有一个servletContext对象实例
    2：servletContext对象，在web工程部署启动时创建，在web工程停止时销毁
    作用：
        //ServletContext servletContext = getServletConfig().getServletContext();
        ServletContext servletContext = getServletContext();
        //1、获取配置在web.xml文件中的上下文参数<context-param>
        String username = servletContext.getInitParameter("username");
        String password = servletContext.getInitParameter("password");
        System.out.println("用户名："+username);
        System.out.println("密码为："+password);
        //2、获取当前工程的路径
        String contextPath = servletContext.getContextPath();
        System.out.println(contextPath);
        //3、获取工程部署到服务器后硬盘上的绝对路径
        String realPath = servletContext.getRealPath("/");
        System.out.println(realPath);
        //4、存取数据
        servletContext.setAttribute("key1","value1");//存
        System.out.println(servletContext.getAttribute("key1"));//取

常见的get/post请求

get:
  >form标签 method=get
  >a标签
  >link标签引入css
  >script标签引入js文件
  >img标签引入图片
  >iframe标签引入html页面
  >在浏览器地址栏中输入地址敲回车
post:
  >from标签 method=post
切记：
   //设置请求体的字符编码，解决中文乱码（针对post请求）
     req.setCharacterEncoding("utf-8");//获取数据之前调用才有效

javaweb中“/”的意义

/ 被浏览器解析为 http://ip:port/
/ 被服务器解析为 http://ip:port/工程路径
特殊情况：response.sendRedirect("/"); 把斜杠发送给浏览器解析得到 http://ip:port/

请求重定向的特点

实现：resp.sendRedirect("地址");
1:浏览器的地址会发生改变
2:浏览器发送两次请求
3:不能共享request域中的数据
4:不能访问WEB-INF下的资源
5:可以访问工程外的资源

Jsp九大内置对象

request： 请求对象
response:   响应对象
pageContext:  jsp的上下文对象
session: 会话对象
application: ServletContext对象
config: ServletConfig对象
out: jsp的输出流对象
page: 当前jsp对象
exception: 异常对象

jsp的四大域对象：
                              类                                    存储数据的生命周期
		pageContext         pageContextImpl类                        当前jsp页面范围
		
		request             HttpRequestServlet类                      同一次请求内
		  
		session             HttpSession 类                            同一次会话内（浏览器关闭位置）
          
        application         ServletContext类                          同一个web工程（web工程关闭为止）

jsp的静态包含
<%@ include file="路径"%>
动态包含：<jsp:include page="路径"></jsp:include>
请求转发：<jsp:forward page="路径"></jsp:forward>

ServletContextListener的使用步骤

1、创建一个类实现ServletContextListener接口
例如：
  
public class MyServletContextListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        System.out.println("ServletContext对象被创建了");
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {
        System.out.println("ServletContext对象被销毁了");
    }
}
2、在web.xml文件中配置

    <listener>
        <listener-class>com.jsp.listener.MyServletContextListener(监听器的全类名)</listener-class>
    </listener>

EL表达式11个隐含对象

  变量                   类型                      作用
pageContext           pageContextImpl         它可以获取jsp的九大内置对象


pageScope             Map<String,Object>      它可以获取PageContext域中的数据
requstScope           Map<String,Object>      它可以获取request域中的数据
sessionScope          Map<String,Object>      它可以获取session域中的数据
applicationScope      Map<String,Object>      它可以获取servletContext域中的数据


param                 Map<String,String>      获取请求参数的值
paramValues           Map<String,String[]>    获取请求参数多个值的时候使用
header                Map<String,String>      获取请求头的信息
headerValues          Map<String,String[]>    获取请求头多个信息的情况下使用
cookie                Map<String,Cookie>      获取当前器请求的cookie信息
initParam             Map<String,String>      获取在web.xml中配置的<context-param>的上下文参数


pageContext 常用的几个方法
1、获取协议 ${pageContext.request.scheme}
2、获取服务器的ip ${pageContext.request.serverName}
3、获取服务器的端口 ${pageContext.request.serverPort}
4、获取工程路径 ${pageContext.request.contextPath}
5、获取请求的方法 ${pageContext.request.method}
6、获取客户端的ip地址 ${pageContext.request.remoteHost}
7、获取会话的id编号 ${pageContext.session.id}

文件的上传和下载

上传：
form表单进行文件的上传
<form acction="路径" method="post" enctype="multipart/form-data"></form>

解析：
在servlet程序中进行解析
导入第三方jar包： commons-fileupload-1.2.1.jar  commons-io-1.4.jar
 //1 判断上传的数据是否为多段数据（只有多段的数据才是文件上传的）
        if (ServletFileUpload.isMultipartContent(req)) {
            //创建FileItemFactory工厂实现类
            FileItemFactory fileItemFactory = new DiskFileItemFactory();
            //创建解析上传数据的工具类
            ServletFileUpload servletFileUpload = new ServletFileUpload(fileItemFactory);
            //解析上传的数据 得到每一个表单项FileItem
            try {
                List<FileItem> list = servletFileUpload.parseRequest(req);
                //循环遍历判断每一个FileItem 为普通类型还是上传的文件
                for(FileItem fileItem:list) {
                    //普通类型
                    if(fileItem.isFormField()) {
                        System.out.println("表单项name属性的值：" + fileItem.getFieldName());
                        //解决乱码
                        System.out.println("表单项属性value的值：" + fileItem.getString("utf-8"));
                    } else {
                        //上传的文件
                        System.out.println("表单项name属性的值：" + fileItem.getFieldName());
                        System.out.println("上传的文件名："+ fileItem.getName());
                        //输出文件
                        fileItem.write(new File("E:\\" + fileItem.getName()));
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
 下载：
 //1、获取要下载的文件名
        String downFileName = "1.jpg";

        //2、和获取要下载的文件类型
        ServletContext servletContext = getServletContext();
        String mimeType = servletContext.getMimeType("/file/" + downFileName);
        System.out.println(mimeType);

        //3、在回传前，设置响应头返回数据的类型
        resp.setContentType(mimeType);

        //4、告诉客户端收到的数据用于下载
         //4、告诉客户端收到的数据用于下载
       if (req.getHeader("User-Agent").contains("Firefox")) {
           //火狐浏览器使用base64编码 解决下载文件时显示中文的文件名
           resp.setHeader("Content-Disposition","attachment;filename==?UTF-8?B?" + new BASE64Encoder().encode("中国.jpg".getBytes("utf-8")) + "?=");  
       } else {
           resp.setHeader("Content-Disposition","attachment;filename=" + URLEncoder.encode("中国.jpg","utf-8"));
       }

        //5、获取要下载的内容 开始下载
        InputStream resourceAsStream = servletContext.getResourceAsStream("/file/" + downFileName);
        //获取响应的输出流
        ServletOutputStream outputStream = resp.getOutputStream();
        //读取输入流中数据 复制给输出流
        IOUtils.copy(resourceAsStream,outputStream);

Cookie

//创建cookie
Cookie cookie = new Cookie(键，值);
//参数为正 表示cookie的有效时间 为0客户端会立即删除改cookie 为负浏览器关闭 改cookie被删除
cookie.setMaxAge(参数)
//告诉客户端存储cookie
resp.addCookie(cookie);
//修改cookie 遍历cookie数组找到要修改的cookie对象 调用setvalue(值)
req.getCookies();//返回值为cookie对象组成的数组
例如： 
  Cookie cookie = CookieUtils.findCookie("key1",req.getCookies()); //遍历cookie数组找到要修改的cookie对象
  if (cookie != null) {
            cookie.setValue("newValue1");
            resp.addCookie(cookie);
  }

Session

//创建和获取session会话对象
HttpSession session = req.getSession();

//判断当前的会话对象是否为新创建出来的
boolean isNew = session.isNew();
//获取session会话的唯一标识
String id = session.getId();

//在web.xml配置文件中进行如下的配置可以改变web工程下所有session的默认有效时长
<session-config>
   <session-timeout>时长(以秒为单位)</session-timeout>
</session-config>

//时长为正 对当前的session设置有效时长  时长为负 改session永不超时 
req.getSession().setMaxInactiveInterval(时长);

//让session会话立即超时
 req.getSession().invalidate();

表单重复提交的情况和解决方法

1、提交完表单。服务器使用请求转发来实现页面的跳转，这个时候按下F5键，就会发起最后一次请求。造成表单的重复提交：解决办法： 使用重定向来实现页面的跳转。
2、用户正常提交给服务器，由于网络较慢，用户多次点击提交，造成表单的重复提交。
3、网络正常，提交完成后，回退浏览器再次提交 造成表单的重复提交。
后两种情况采用验证码的来来解决

采用谷歌第三方jar包实现验证码  生成的验证码会自动保存到session域中
   >导入jar包kaptcha-2.3.2.jar
   >在web.xml中进行如下的配置 ：   
           <servlet>
                <servlet-name>KaptchaServlet</servlet-name>
                <servlet-class>com.google.code.kaptcha.servlet.KaptchaServlet</servlet-class>
           </servlet>
           <servlet-mapping>
               <servlet-name>KaptchaServlet</servlet-name>
               <url-pattern>/vertifition.jpg</url-pattern>
          </servlet-mapping>
          //每访问一次配置的网址就会得到一个验证码
   >将验证码引入到表单中：
         <img src="http://ip:port/工程名/vertifition.jpg">
   > 在服务器中获取验证码
        //获取验证码
        String token = (String)req.getSession().getAttribute(KAPTCHA_SESSION_KEY);
        //删除验证码
        req.getSession().removeAttribute(KAPTCHA_SESSION_KEY);

Filter

filter:作用 拦截请求，过滤响应
应用场景：
   >权限检查
   >日记操作
   >事务管理
使用步骤：
>创建一个类实现Filter接口  
		public class AdminFilter implements Filter {
		    @Override
		    public void init(FilterConfig filterConfig) throws ServletException {
		    }
		    @Override
		    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws    IOException, ServletException {
		        HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
		        HttpSession session = httpServletRequest.getSession();
		        Object user = session.getAttribute("user");
		        if (user == null) {
		            servletRequest.getRequestDispatcher("/index.jsp").forward(servletRequest,servletResponse);
		            return;
		        } else {
		            //让请求继续向下走
		            //作用：1、执行下一个Filter（如果有） 2、执行目标资源 （没有Filter）
		            
		            filterChain.doFilter(servletRequest,servletResponse);
		        }
		    }
		    @Override
		    public void destroy() {
		    }
		}
>在web.xml文件中进行配置 
 <!--配置filter-->
    <filter>
        <filter-name>AdminFilter</filter-name>
        <filter-class>com.learn.filter.AdminFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>AdminFilter</filter-name>
        <!--配置拦截路径-->
        <url-pattern>/admin/*</url-pattern>
    </filter-mapping>
 //多个过滤器执行的顺序由在web.xml配置文件中配置的从上到下顺序决定
 //所有的filter和目标资源默认都执行在同一个线程内
 //多个filter共同执行的时候，他们都使用同一个request对象

多个过滤器执行示意图

ThreadLoacl的使用

ThreadLoacl的作用：解决多线程数据安全的问题
ThreadLocal可以给当前的线程关联一个数据（这个数据可以是普通变量、对象、数组、集合）
特点：
   >ThreadLocal为当前线程关联一个数据（可以像map一样存取） // 存 threadLocal.set(Obj)  取 threadLocal.get() 
   >每一个ThreadLocal对象，只能为当前线程关联一个数据，如果要关联多个数据，就要使用多个ThreadLocal对象
   >每个ThreadLocal对象一般定义为static //private static ThreadLocal<Object> threadLocal = new ThreadLocal<>();
   >ThreadLocal对象中关联的数据，线程销毁后，由JVM自动释放

Tomcat展示错误友好页面的配置

//配置服务器出错之后 自动跳转的页面
<error-page>
    //错误类型
    <error-code>500</error-code>
    //要跳转页面的路径
    <location>/error500.jsp</location>
</error-page>

Json在java中的转换

导入gson-2.2.4.jar包
1、javaBean与JSON的互转
        Person person = new Person(1,"zhang");
        //javaBean 转换为JSON
        Gson gson = new Gson();
        String s = gson.toJson(person);
        System.out.println(s);
        //JSON 转换为 JavaBean
        Person person1 = gson.fromJson(s, Person.class);
        System.out.println(person1);
2、JSON与List互转
        List<Person> list = new ArrayList<>();
        list.add(new Person(1,"zhang"));
        list.add(new Person(2,"feng"));
        //list转化为JSON
        Gson gson = new Gson();
        String s = gson.toJson(list);
        System.out.println(s);
        //JSON转化为list  
        List<Person> personList = gson.fromJson(s, new TypeToken<List<Person>>(){}.getType());
        System.out.println(personList);
3、map与JSON互转
        Map<Integer,Person> map = new HashMap<>();
        map.put(1,new Person(1,"zhang"));
        map.put(2,new Person(2,"feng"));
        //map 转换为JSON
        Gson gson = new Gson();
        String s = gson.toJson(map);
        System.out.println(s);
        //json 转换为 map
        Map<Integer,Person> maps = gson.fromJson(s, new TypeToken<Map<Integer,Person>>(){}.getType());
        System.out.println(maps);