cookie的使用 java jsp cookie javaweb

转载

level 2023-10-12 15:54:47

文章标签 cookie的使用 java jsp cookie session i18n javaweb 文章分类 Java 后端开发

文章目录

1.Cookie 饼干
2. Cookie 使用
3. Cookie 原理分析
4. cookie的细节处理

4.1 一次发送多个cookie
4.2 Cookie 存活时间
4.3 cookie 能不能存储中文？
4.4 cookie 的范围

5. Cookie的特点和作用
6. Session 会话
7.如何创建Session？
8. Session 域对象存储数据
9. Session 生命周期控制
10. Session 和浏览器之间有什么关联
11. Filter 过滤器
12. Filter 的使用
13. Filter 的web配置
14. Filter 生命周期
15. Filter 拦截路径的配置
16. Filter 拦截方式的配置

16.1 Filter 注解拦截配置
16.2 web.xml 配置和 ServletRequest

17. chain过滤器链(配置多个过滤器)
18. JSON

18.1 json 定义
18.2 json的两个常用方法
18.3 服务器端如何使用JSON？

18.3.1 JavaBean 和 json 的互传
18.3.2 List 和 json 的互传
18.3.3 Map 和 json 的互换

19. i18n 国际化

19.1 i18n 国际化定义
19.2 i18n 三要素
19.3 i18n 通过请求头实现国际化
19.4 i18n 通过语言类型选择实现国际化
19.5 i18n 使用JSTL标签库fmt实现国际化

20. 对dao，controller，service，bean/pojo，util层的总结
21. 补充

21.1 bigDecimal 传参

22. 接口文档的标准
23. filter登录验证效果
24. classpath 和 classpath\* 区别

1.Cookie 饼干

Cookie 是服务器通知客户端保存键值对的一种技术。
cookie是servlet发送到Web浏览器的少量信息，这些信息由浏览器保存，然后发送回服务器。cookie的值可以唯一地标识客户端，因此cookie常用语会话管理。
客户端有了cookie后，每次请求都会把cookie发送给服务器端。
每个cookie的大小不能超过4kb。

会话：一次会话中包含多次请求和响应。

客户端会话技术：Cookie

服务端会话技术：session

我们可以通过cookie.setDomin()定义好发送域名。

cookie.setPath()定义好发送的url地址。

这些每一个cookie对象都有默认值的！

2. Cookie 使用

概念：客户端会话技术，将数据保存到客户端。

Cookie是键值对形式存在，通常存储请求头中。

使用步骤：

服务器端创建Cookie对象，指定数据。

Cookie cookie = new Cookie(String name , String value);//创建Cookie

服务器端发送Cookie对象，给客户端。

response.addCookie(cookie);//发送Cookie给客户端。

客户端发送数据时，也发送Cookie，给服务器端。

Cookie[] cookieArr = request.getCookies();//获得cookie数组

例如：

创建一个CookieDemo1，用来发送cookie给客户端。

package com.cookie;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/cookieDemo1")
public class CookieDemo1 extends HttpServlet{
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		//1.创建Cookie对象
		Cookie cookie = new Cookie("msg","hello");
		//2.发送Cookie
		resp.addCookie(cookie);
	}
	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		// TODO Auto-generated method stub
		this.doGet(req, resp);
	}
}

在创建一个CookieDemo2，用来测试接受客户端发送过来的cookie。

package com.cookie;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/cookieDemo2")
public class CookieDemo2 extends HttpServlet{
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		//3.获取Cookie
		Cookie[] cookies = req.getCookies();
		
		//根据数据，遍历Cookies
		if(cookies != null) {
			for(Cookie c:cookies) {
				String name = c.getName();
				String value = c.getValue();
				System.out.println(name+":"+value);
			}
		}
	}
	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		// TODO Auto-generated method stub
		this.doGet(req, resp);
	}
}

我们访问/cookieDemo1，再访问/cookieDemo2，就发现内容已经被打印，返回了cookie名和值，因为处在同一会话中，客户端已经存储了cookie值。

cookie的使用 java jsp cookie javaweb_i18n

3. Cookie 原理分析

cookie的使用 java jsp cookie javaweb_cookie_02

服务器端向客户端发送cookie，通过响应头的set-cookie:key=value来发送。

客户端向服务端发送cookie，通过请求头的cookie:key=value来发送。

cookie的使用 java jsp cookie javaweb_cookie_03

4. cookie的细节处理

4.1 一次发送多个cookie

发送多个cookie，那就多调动addCookie方法来呗。

package com.cookie;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/cookieDemo1")
public class CookieDemo1 extends HttpServlet{
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		
		Cookie cookie1 = new Cookie("msg","hello");
		Cookie cookie2 = new Cookie("name","zhangsan");
		
		//可以发送多个cookie
		resp.addCookie(cookie1);
		resp.addCookie(cookie2);
	}
	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		// TODO Auto-generated method stub
		this.doGet(req, resp);
	}
}

4.2 Cookie 存活时间

默认情况下，当浏览器关闭后，Cookie数据被销毁。

当然，我们可以持久化存储cookie：通过setMaxAge(int seconds) 方法。

setMaxAge(int seconds)：

正数：将Cookie数据写到硬盘的文件中。持久化存储。cookie存活时间。
负数：负数就代表默认值。
零：服务器端想要删除客户端的cookie信息，就定义为零，就删除cookie信息。

package com.cookie;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/cookieDemo1")
public class CookieDemo1 extends HttpServlet{
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		
		Cookie cookie1 = new Cookie("msg","hello");
		
		//将Cookie数据写到硬盘的文件中,30秒之内会删除cookie
		//cookie1.setMaxAge(30);
		
		//默认
		//cookie1.setMaxAge(-1);
		
		//删除cookie信息
		cookie1.setMaxAge(0);
		resp.addCookie(cookie1);

	}
	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		// TODO Auto-generated method stub
		this.doGet(req, resp);
	}
}

4.3 cookie 能不能存储中文？

tomcat 8之前，cookie是不能支持存储中文数据的。

那么tomcat 8之前，我们一般采用url编码或base64编码来存储中文进行发送。

tomcat 8之后，cookie支持中文数据。

4.4 cookie 的范围

一个tomcat服务器，部署了多个web项目，那么这些web项目中的cookie能不能共享？

默认情况下，cookie是不能共享的。

setPath(String path): 设置cookie的范围取值。默认情况下，设置当前的虚拟目录。

如果要共享，则可以将path设置为" / "(范围大一点)，就是http://localhost:8080/ ，以后的路径，都可以共享这个cookie。

不同的tomcat服务器cookie共享问题？

setDomain(String path)：如果设置一级域名相同，那么多个服务器之间cookie可以共享。

setDomain(“.baidu.com”) , 那么tieba.baidu.com和new.baidu.com中cookie可以共享。

5. Cookie的特点和作用

cookie的特点：

cookie存储数据在客户端浏览器。
浏览器对于单个cookie的大小有限制(4kb)以及对同一个域名下的总cookie数量也有限制(一般20个)。

cookie的作用：

cookie一般用于存储少量的不太敏感的数据。
在不登录的情况下，完成服务器对客户端的身份识别。

cookie的使用 java jsp cookie javaweb_javaweb_04

6. Session 会话

Session就是一个接口(HttpSession)。

Session就是会话。它是用来维护一个客户端和服务器之间关联的一种技术。

每个客户端都有自己的一个Session会话。

Session会话中，我们经常用来保存用户登录之后的信息，是在服务器端的。

7.如何创建Session？

在Servlet中，我们有request这样的api参数。

因此，我们直接可以使用request.getSession()方法来创建。

主要注意第一次调用是：创建Session会话，以后调用便是获取第一次创建的Session会话了。

如果我们想要判断当前的Session是不是刚刚创建出来的，官方给出了一个isNew()的方法，来判断是不是刚刚创建出来的Session。

每个Session会话都有一个id值，这个id是唯一的！

通过getId()方法来得到Session的会话id值。

package com.test.day02;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@WebServlet(value="/session1")
public class HttpSessionTest extends HttpServlet{
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		// TODO Auto-generated method stub
		
		//创建session会话，一个会话只会创建一次，往后调用都只调用该会话一次。
		HttpSession session = req.getSession();
		
		//session.isNew()方法：判断是不是刚刚创建的session会话
		boolean new1 = session.isNew();
		System.out.println(new1);
		
		String id = session.getId();
		System.out.println(id);
		
		System.out.println();
		
	}
	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		// TODO Auto-generated method stub
		this.doGet(req, resp);
	}
}

cookie的使用 java jsp cookie javaweb_javaweb_05

8. Session 域对象存储数据

既然存域对象数据，肯定调用setAttribute()方法啥的。

package com.test.day02;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@WebServlet(value="/session1")
public class HttpSessionTest extends HttpServlet{
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		// TODO Auto-generated method stub
		
		//创建session会话，一个会话只会创建一次，往后调用都只调用该会话一次。
		HttpSession session = req.getSession();
		
		session.setAttribute("key1", "value1");
		
		Object attribute = session.getAttribute("key1");
		
		System.out.println();
		
	}
	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		// TODO Auto-generated method stub
		this.doGet(req, resp);
	}
}

9. Session 生命周期控制

设置Session的超时时长，超过指定的时长，Session就会被销毁。这里是以秒为单位的

session.setMaxInactiveInterval(1000);

获取Session的超时时长，如果设置超时时长它是有默认时长的(默认时长为1800秒，也就是30分钟，这个是可以修改的可以去tomcat服务器web.xml去配置默认时长)。

int maxInactiveInterval = session.getMaxInactiveInterval();

tomcat默认session超时时长的web.xml配置：

cookie的使用 java jsp cookie javaweb_session_06

在服务端，如果session在规定的超时时间内，还没有接受到该session的请求，一旦超时它就会被删除。

如果在超时时间内接受到请求了，那么超时时长就会重新计时，原理就这么简单。

再就是如果超时时长设置为负数，那么它就永远不超时。

还有一个invalidate()方法，该方法作用就是让当前session会话马上超时无效。

package com.test.day02;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@WebServlet(value="/session1")
public class HttpSessionTest extends HttpServlet{
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		// TODO Auto-generated method stub
		
		//创建session会话，一个会话只会创建一次，往后调用都只调用该会话一次。
		HttpSession session = req.getSession();
		
		//session.isNew()方法：判断是不是刚刚创建的session会话
		boolean new1 = session.isNew();
		System.out.println(new1);
		
		String id = session.getId();
		System.out.println(id);
		
		session.setAttribute("key1", "value1");
		
		Object attribute = session.getAttribute("key1");
		
		//设置Session的超时时长，超过指定的时长，Session就会被销毁。这里是以秒为单位的
		//session.setMaxInactiveInterval(1000);
		
		//获取Session的超时时长，如果设置超时时长它是有默认时长的(默认时长为1800秒，也就是30分钟，这个是可以修改的可以去tomcat服务器web.xml去配置默认时长)。
		int maxInactiveInterval = session.getMaxInactiveInterval();
		
		//让session会话，立刻超时！
		session.invalidate();
		resp.getWriter().write("session已经被设置为超时了");
		
		System.out.println();
		
	}
	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		// TODO Auto-generated method stub
		this.doGet(req, resp);
	}
}

10. Session 和浏览器之间有什么关联

cookie的使用 java jsp cookie javaweb_i18n_07

其实，服务器端第一次创建session对象时，它会创建一个cookie对象，对象的键为：JSESSIONID，值为：新创建出来的Session的id值。

换句话说，session技术，底层其实是基于cookie技术来实现的。

11. Filter 过滤器

Filter过滤器是JavaWeb的三大组件之一。

Filter过滤器它是JavaEE的规范，也就是接口。

Filter过滤器的作用就是: 拦截请求，过滤响应。

常见操作：

自动登录
统一设置编码格式
访问权限控制
敏感字符过滤等。

12. Filter 的使用

步骤：

1.定义一个类，实现接口Filter(javax.servlet.Filter下的)。
2.重写方法。
3.配置拦截路径。

一次请求中，要经过两次过滤拦截，进来时，过滤一次；发送响应数据过滤一次。

简单注解使用：

package com.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.annotation.WebFilter;

//注解用法 ， " /* "访问所有资源都要执行该过滤器。
@WebFilter("/*") 
public class FilterDemo01 implements Filter {

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
	}

	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {

		System.out.println("Filter被执行了");

		// 放行操作
		chain.doFilter(request, response);
		//这一步骤的意思就是，如果不执行这句活，客户端访问我们的前端页面是访问不到任何内容的，因为被拦截了
	}

	@Override
	public void destroy() {
	}

}

13. Filter 的web配置

过滤器的web.xml配置和Servlet配置差不多的：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  
	<filter>
		<filter-name>FilterTest02</filter-name>
		<filter-class>com.filter.FilterTest02</filter-class>
	</filter>
  	<filter-mapping>
  		<filter-name>FilterTest02</filter-name>
  		<!--配置拦截路径-->
  		<url-pattern>/*</url-pattern>
  	</filter-mapping>
  	
</web-app>

14. Filter 生命周期

过滤器执行流程：

执行过滤器
执行放行后的资源。
回来执行过滤器放行代码下边的代码。

理解一个请求中，经过两次过滤拦截：

过滤器的生命周期：

init：在服务器启动后，会创建Filter对象，然后调用init方法。只执行一次，用于加载资源。
doFilter：每一次请求被拦截时，doFilter方法就会被执行，被执行多次。
destroy：在服务器关闭后，Filter对选哪个被销毁。如果服务器是正常关闭，则会执行destroy方法。只执行一次，用于释放资源。

package com.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.annotation.WebFilter;

@WebFilter("/*")
public class FilterTest03 implements Filter{

	//在服务器启动后，会创建Filter对象，然后调用init方法。只执行一次，用于加载资源。
	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		System.out.println("init...");
	}

	//每一次请求被拦截时，doFilter就会被执行，被执行多次。
	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		System.out.println("doFilter...");
	}

	//在服务器关闭后，Filter对选哪个被销毁。如果服务器是正常关闭，则会执行destroy方法。只执行一次，用于释放资源。
	@Override
	public void destroy() {
		System.out.println("destroy...");
	}
	
}

15. Filter 拦截路径的配置

拦截路径配置：

具体资源路径：/index.jsp 只有访问index.jsp资源时，过滤器才会被执行。
拦截目录：/test/* 方位/test下的所有资源时，过滤器都会被执行。
后缀名拦截：*.jsp 访问所有资源时，过滤器都会被执行。
拦截所有资源：/* 访问所有资源时，过滤器都会被执行。

16. Filter 拦截方式的配置

16.1 Filter 注解拦截配置

注解配置：

设置dispatcherTypes属性。

request：默认值。浏览器直接请求资源。
forward：抓发访问资源。
include：包含访问资源。
error：错误跳转。
async：异步访问资源。(sync：同步，async：异步)

dispatcherTypes = DispatcherType.REQUEST;

浏览器直接请求资源index.jsp时，该过滤器会被执行，像那些请求抓发的操作就不会执行。

cookie的使用 java jsp cookie javaweb_cookie的使用 java jsp_09

dispatcherTypes = DispatcherType.FORWARD;

只有请求抓发访问index.jsp时，该过滤器才会被执行。

cookie的使用 java jsp cookie javaweb_cookie_10

请求访问和转发都想被filter拦截处理，那就用数组方式来解决。

cookie的使用 java jsp cookie javaweb_cookie的使用 java jsp_11

16.2 web.xml 配置和 ServletRequest

web.xml 配置:

doFilter方法中的ServletRequest，一般使用的时候一定强转为HttpServletRequest，因为多数方法都在HttpServletRequest中。

cookie的使用 java jsp cookie javaweb_cookie的使用 java jsp_13

17. chain过滤器链(配置多个过滤器)

我们定义的一个过滤器，在doFilter方法中的chain，英文直译是链的意思。

对于多个filter就像一个链子，一个个串联起来，一层层走。

chain.doFilter(request,response)是对于当前链子实现的一个放行功能效果。

过滤器还是照常拦截过滤的，主要是顺序需要注意！

首先，先按照顺序执行web.xml配置的过滤器；之后按照字典顺序(0~9, a~z)，就是按照0~9或a~z的顺序来对注解排顺序。

cookie的使用 java jsp cookie javaweb_i18n_14

请求时按照上面顺序来，服务器响应数据经过过滤器时，恰好反着来。

cookie的使用 java jsp cookie javaweb_javaweb_15

18. JSON

18.1 json 定义

JSON(JavaScirpt Object Notation)是一种轻量级的数据交换格式。

轻量级指的是跟xml作比较，很轻量。

数据交换指的是客户端和服务器之间业务数据的传递格式。

json定义：
json是由键值对组成，并且由花括号(大括号)包围，键和值之间使用冒号进行分割，多组键值对之间进行逗号进行分割。

json就是一个对象。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
<script type="text/javascript">
    var jsonObj = {
      "key1":12,
      "key2":"abc",
      "key3":true,
      "key4":[11,"abc"],
      "key5":{
        "key5.1":123,
        "key5.1":"def"
      }
    }

    alert(typeof jsonObj) //可以发现是Object，因此json就是一个对象。
</script>
</head>
<body>

</body>
</html>

18.2 json的两个常用方法

JSON存在两种形式：

一种是对象的形式存在，叫做json对象。
一种是字符串的形式存在，叫做json字符串。

因此，对应两种方法进行转换：

JSON.stringify()：把json对象转换成为json字符串。
JSON.parse()：把json字符串转换为json对象。

一般我们要操作json中的数据的时候，需要json对象的格式。

一般我们要在客户端和服务器之间进行数据交换的时候，使用json字符串。

18.3 服务器端如何使用JSON？

18.3.1 JavaBean 和 json 的互传

javaBean 和 Json 的转换：

1.导入gson的jar包(去maven下载)。
2.创建gson实例对象。
3.调用gson的toJson方法可以将java对象转换成为json字符串形式。
4.调用gson的fromJson把json字符串转换回java对象。

package com.itholmes;

import org.junit.Test;

import com.google.gson.Gson;

public class JsonTest {
	//javaBean 和 Json 的转换
	@Test
	public void test01() {
		
		//我自己定义了person对象，设定id和name值。
		Person person = new Person(1,"itholmes");
		
		//创建gson对象实例
		Gson gson = new Gson();
		
		//toJson方法可以将java对象转换成为json字符串形式。
		String json = gson.toJson(person);
		System.out.println(json);
		
		//fromJson把json字符串转换回java对象:
		//第一个参数是json字符串，第二个参数是转换回去的java对象类型
		Person fromJson = gson.fromJson(json, Person.class);
		System.out.println(fromJson);
		
	}
}

Person类如下：

package com.itholmes;

public class Person {
	private Integer id;
	private String name;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Person [id=" + id + ", name=" + name + "]";
	}
	public Person(Integer id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	
}

18.3.2 List 和 json 的互传

注意TypeToken的作用？？？要搞清楚！

package com.itholmes;

import java.util.List;

import com.google.gson.reflect.TypeToken;

public class PersonListType extends TypeToken<List<Person>>{
	
}

package com.itholmes;

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

import com.google.gson.Gson;

public class JsonTest {
	
	//List 和 json 的互传
	@Test
	public void test02() {
		List<Person> list = new ArrayList<Person>();
		
		list.add(new Person(1,"itholmes01"));
		list.add(new Person(2,"itholmes02"));
		
		Gson gson = new Gson();
		//把list集合中的转换为字符串数组
		String json = gson.toJson(list);
		System.out.println(json);
		
		List fromJson = gson.fromJson(json, new PersonListType().getType());
		System.out.println(fromJson);
		
		//我们想要转换为person类型，仅仅是用list.class是不行的，我们要使用gson包中的TypeToken。
		Person p =  (Person) fromJson.get(0);
		System.out.println(p);
	}
}

18.3.3 Map 和 json 的互换

和集合差不多：

继承TypeToken<Map<Integer,Person>>的类：

package com.itholmes;

import java.util.Map;

import com.google.gson.reflect.TypeToken;

public class PersonMapType extends TypeToken<Map<Integer,Person>>{
	
}

package com.itholmes;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.Test;

import com.google.gson.Gson;

public class JsonTest {
	//Map 和 json 集合转换
	@Test
	public void test03() {
		Map<Integer,Person> map = new HashMap<Integer, Person>();
		map.put(1, new Person(1,"itholmes01"));
		map.put(2, new Person(2,"itholmes02"));
	
		Gson gson = new Gson();
		String json = gson.toJson(map);
		System.out.println(json);
		
		Map<Integer,Person> fromJson = gson.fromJson(json, new PersonMapType().getType());
		
		System.out.println(fromJson);
		
		Person p = fromJson.get(2);
		System.out.println(p);
	}
}

除了上面直接创建对象来获取type类型，我们还可以直接创建匿名类的操作：

Map<Integer,Person> fromJson = gson.fromJson(json, new TypeToken<Map<Integer,Person>>() {}.getType());

上面的方式就不用另外创建类对象去了，很简单！

19. i18n 国际化

19.1 i18n 国际化定义

国际化的英文：Internationalization。

由于拼写过长，就以i开头，以n结尾，中间18个字母，也就简化为了i18n。

19.2 i18n 三要素

cookie的使用 java jsp cookie javaweb_session_16

cookie的使用 java jsp cookie javaweb_cookie_17

代码内容如下(就是对象上面来的)：

package com.itholmes.i18n;

import java.util.Locale;
import java.util.ResourceBundle;

import org.apache.tomcat.jni.Local;
import org.junit.Test;

public class I18nTest {
	@Test
	public void testLocale() {
		//获取你系统默认的语言，国家信息。
		Locale locale = Locale.getDefault();
		System.out.println(locale);
		
		//查看所有的国家语言信息
		for(Locale availableLocale : Locale.getAvailableLocales()) {
			System.out.println(availableLocale);
		}
		
		//获取中文，中文的常量的locale对象
		System.out.println(Locale.CHINA);
		//获取英文，美国的常量locale对象
		System.out.println(Locale.US);
		
	}
	@Test
	public void testI18n() {
		Locale ch = Locale.CHINA;
		Locale us = Locale.US;
	
		ResourceBundle bundle = ResourceBundle.getBundle("i18n",ch);
		String username = bundle.getString("username");
		String password = bundle.getString("password");
		String sex = bundle.getString("sex");
		String age = bundle.getString("age");
		
		ResourceBundle bundle2 = ResourceBundle.getBundle("i18n",us);
		String username2 = bundle2.getString("username");
		String password2 = bundle2.getString("password");
		String sex2 = bundle2.getString("sex");
		String age2 = bundle2.getString("age");
		
		System.out.println();
	}
}

19.3 i18n 通过请求头实现国际化

通过请求头实现，就是页面发送请求协议携带Accept-Language信息，发送到浏览器。

cookie的使用 java jsp cookie javaweb_cookie_18

通过request.getLocale()拿到我们需要发送的格式，进而通过bundle.getString()方法获取。

<%@page import="java.util.ResourceBundle"%>
<%@page import="java.util.Locale"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<% 
		Locale locale = request.getLocale();
		System.out.println(locale);
		ResourceBundle bundle = ResourceBundle.getBundle("i18n",locale);
	%>
	
	请求头发送Accept-Language类型是什么就返回响应的:<br>
	<%=bundle.getString("username") %><br>
	<%=bundle.getString("password") %><br>
	<%=bundle.getString("sex") %><br>
	<%=bundle.getString("age") %><br>
</body>
</html>

19.4 i18n 通过语言类型选择实现国际化

cookie的使用 java jsp cookie javaweb_javaweb_19

平时，我们可能遇到这种有个按钮，可以中文转换英文，英文转换中文，可以按照下面代码格式来操作转换：

<%@page import="java.util.ResourceBundle"%>
<%@page import="java.util.Locale"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<% 
		Locale locale = null;
	
		String typeLangu = request.getParameter("typeLangu");
		
		if("cn".equals(typeLangu)){
			locale = Locale.CHINA;
		}else if("usa".equals(typeLangu)){
			locale = Locale.US;
		}else{
			locale = request.getLocale();
		}
		
		System.out.println(locale);
				ResourceBundle bundle = ResourceBundle.getBundle("i18n",locale);
	%>
	
	<a href="a.jsp?typeLangu=cn">中文</a>|
	<a href="a.jsp?typeLangu=usa">英文</a>
	<br>
	请求头发送Accept-Language类型是什么就返回响应的:<br>
	<%=bundle.getString("username") %><br>
	<%=bundle.getString("password") %><br>
	<%=bundle.getString("sex") %><br>
	<%=bundle.getString("age") %><br>
</body>
</html>

19.5 i18n 使用JSTL标签库fmt实现国际化

我们，平时一般不适用jsp代码格式来写代码，反而使用EL表达式或JSTL标签库来修饰jsp。

JSTL标签库使用：<%@ taglib prefix=“fmt” uri=“http://java.sun.com/jsp/jstl/fmt” %>

步骤如下：

<%@page import="java.util.ResourceBundle"%>
<%@page import="java.util.Locale"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>

	<a href="b.jsp?locale=zh_CN">中文</a>|
	<a href="b.jsp?locale=en_US">english</a><br>
	
	<!--1. 使用fmt:setLocale标签设置Locale信息：-->
	<fmt:setLocale value="${param.locale}"/>
	
	<!--2. 使用fmt:setBundle标签设置baseName的值-->
	<fmt:setBundle basename="i18n"/>
	
	<!--3. 使用标签输出国际化信息。-->
	<fmt:message key="username"/><br>
	<fmt:message key="password"/><br>
	<fmt:message key="sex"/><br>
	<fmt:message key="age"/><br>
	
	
</body>
</html>

注意：EL表达式中${xxx}内部不要有多余空格，不然不起作用！

20. 对dao，controller，service，bean/pojo，util层的总结

这种层级效果必须记住！

controller层：是请求接受响应层，也就是servlet层。
dao层：数据访问层，负责调用数据库中的数据返回出来，传递给service层处理。
service层：业务逻辑层(服务层)，将dao层接受到的数据拿出来，进行业务处理。
bean层/pojo层：实例类层，提供一个能够创建实例对象的实体类，其属性都是private，设置好get和set方法，一般实体类作为一个存储对象的效果。
utils层：JDBCUtils层，负责存放jdbc的具体操作的层。

21. 补充

21.1 bigDecimal 传参

我们通过jsp页面拿到参数，发给servlet，但是对应的数据库中的参数是bigDecimal类型如果传入的为null就会报错！传入为0，在数据库中就显示为null。

因此，我们在前端不管拿到什么参数，一定要判断是否为null或空字符串，进而确定我们不同的结果。

22. 接口文档的标准

cookie的使用 java jsp cookie javaweb_javaweb_20

23. filter登录验证效果

public class MyFilter implements Filter{

	 @Override
	 public void destroy() {
	  // TODO Auto-generated method stub
	  
	 }
	
	 @Override
	 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
	   throws IOException, ServletException{
			  request.setCharacterEncoding("Utf-8");
			  response.setCharacterEncoding("Utf-8");
			  HttpServletRequest req =(HttpServletRequest)request;
			  HttpServletResponse resp = (HttpServletResponse)response;
			  //对登录页面和登录验证页面放行
			  String uri = req.getRequestURI();
			  if(uri.equals(req.getContextPath()+"/login.html")
			    ||uri.equals(req.getContextPath()+"/login") 
			    ||uri.equals(req.getContextPath()+"/js")){
			   chain.doFilter(request, response);
			   return;
			  }
			  //正式开始拦截,b为true时放行，默认不放行
			  boolean b = false;
			  //获取全部cookie
			  Cookie[] cookies = req.getCookies();
			  if(cookies.length>0 && cookies != null){
			   //查找有没有登录验证通过的cookie
			   for (Cookie cookie : cookies) {
			    String name = cookie.getName();
			    if(name.equals("zzy")){
			     //找到了
			     b = true;
			    }
			   }
			  }
			  if(b){
			   //为treu,放行并结束这一切
			   chain.doFilter(req, resp);
			   return;
			  }
			  //莫认不放行，继续去登录
			  req.getRequestDispatcher("/login.html").forward(req, resp);
	  }
	
	 @Override
	 public void init(FilterConfig filterConfig) throws ServletException {
	  // TODO Auto-generated method stub
	  
	 }

}

24. classpath 和 classpath* 区别

classpath 和 classpath* 区别：

classpath：只会到你的class路径中查找找文件;
classpath*：不仅包含class路径，还包括jar文件中(class路径)进行查找.

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：Android支付宝SDK封装支付宝 sdk

下一篇：bp神经网络高斯分布变量 bp神经网络相关系数r

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯