Java基础掌握（三）

一.Session会话机制
1、Session由来
    HTTP的无状态，也就是说，每次请求都是独立的线程。举个例子吧：购物中，你选择了A商品，加入购物车，这就是A线程。然后在选择B商品就是B线程。可是每次线程独立（对容器而言，A、B成了不同的用户），线程A不知道有B，B也不知道A。如何一起付款呢？
简答来说：怎么保存同个用户多个请求会话状态呢？自然HTTPS保证连接是安全的，可以使它与一个会话关联。
2、Session机制
机制，什么用词有点高大上。其实就是把它内在的一点东西说出来。主要两个W：What？How？
1）What is Session?
Session代表着服务器和客户端一次会话的过程。直到session失效（服务端关闭），或者客户端关闭时结束。
2）How does session works？
    Session 是存储在服务端的，并针对每个客户端（客户），通过SessionID来区别不同用户的。Session是以Cookie技术或URL重写实现。默认以Cookie技术实现，服务端会给这次会话创造一个JSESSIONID的Cookie值。
会话管理---Cookie与Session
二.实体类实现Serializable接口
1、Serializable的定义

    Serializable接口是启用其序列化功能的接口。实现java.io.Serializable 接口的类是可序列化的。没有实现此接口的类将不能使它们的任意状态被序列化或逆序列化。“持久化”意味着对象的“生存时间”并不取决于程序是否正在执行——它存在或“生存”于程序的每一次调用之间。通过序列化一个对象，将其写入磁盘，以后在程序再次调用时重新恢复那个对象，就能圆满实现一种“持久”效果。

什么情况下需要序列化？   
    a）当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
    b）当你想用套接字在网络上传送对象的时候；
    c）当你想通过RMI传输对象的时候；

2、Serializable的作用
1）将对象的状态保存在存储媒体中，以便可以在以后重新创建出完全相同的副本；
2）按值将对象从一个应用程序域发送至另一个应用程序域。
总结：实现serializable接口的作用是就是可以把对象存到字节流，然后可以恢复。所以你想如果你的对象没实现序列化怎么才能进行网络传输呢，要网络传输就得转为字节流，所以在分布式应用中，你就得实现序列化，如果你不需要分布式应用，那就没那个必要实现序列化。
3、Serializable的使用
1） Serializable的一些说明：
对象的序列化处理非常简单，只需对象实现了Serializable 接口即可（该接口仅是一个标记，没有方法）；
序列化的对象包括基本数据类型，所有集合类以及其他许多东西，还有Class 对象；
对象序列化不仅保存了对象的“全景图”，而且能追踪对象内包含的所有句柄并保存那些对象；接着又能对每个对象内包含的句柄进行追踪；
使用transient关键字修饰的的变量，在序列化对象的过程中，该属性不会被序列化。

public class Msg implements Serializable{

private static final long serialVersionUID = -6519304261259719883L;

2）序列化的步骤：
首先要创建某些 OutputStream 对象：OutputStream outputStream = new FileOutputStream("output.txt");
将其封装到 ObjectOutputStream 对象内：
ObjectOutputStream objectOutputStream = new  ObjectOutputStream(outputStream);此后只需调用writeObject()即可完成对象的序列化，并将其发送给OutputStream：
objectOutputStream.writeObject(Object);
最后不要忘记关闭资源：objectOutputStream.close(), outputStream .close();
3）反序列化的步骤：
首先要创建某些OutputStream对象：
InputStream inputStream= new FileInputStream("output.txt")
将其封装到ObjectInputStream对象内：
ObjectInputStream objectInputStream= new ObjectInputStream(inputStream);
此后只需调用writeObject()即可完成对象的反序列化：
objectInputStream.readObject();
最后不要忘记关闭资源：
objectInputStream.close()，inputStream.close();

4）简单实现 demo
（1）项目结构如下：



（2）首先我们建立一个Man类，实现了Serializable接口，用于Person类的测试：package com.model;

import java.io.Serializable;

public class Man implements Serializable{
private static final long serialVersionUID = 1L;

private String username;
private String password;

public Man(String username, String password) {
this.username = username;
this.password = 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;
}
}
（3）我们再建立一个Person类，用于序列化：package com.model;

import java.io.Serializable;

public class Person implements Serializable {
private static final long serialVersionUID = 1L;

private Man man;
private String username;
private transient int age;

public Person() {
System.out.println("person constru");
}

public Person(Man man, String username, int age) {
this.man = man;
this.username = username;
this.age = age;
}

public Man getMan() {
return man;
}
public void setMan(Man man) {
this.man = man;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
（4）编写一个包含main方法的测试类：MainTest，它的writeSerializableObject用于序列化对象：package com.test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStreamWriter;

import com.model.Man;
import com.model.Person;

public class MainTest {
public static void main(String[] args) {
writeSerializableObject();
readSerializableObject();
}

// Serializable：把对象序列化
public static void writeSerializableObject() {
try {
Man man = new Man("huhx", "123456");
Person person = new Person(man, "刘力", 21);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("output.txt"));
objectOutputStream.writeObject("string");
objectOutputStream.writeObject(person);
objectOutputStream.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

// Serializable：反序列化对象
public static void readSerializableObject() {
try {
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("output.txt"));
String string = (String) objectInputStream.readObject();
Person person = (Person) objectInputStream.readObject();
objectInputStream.close();
System.out.println(string + ", age: " + person.getAge() + ", man username: " + person.getMan().getUsername());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
}（5）在Main方法添加以上两个方法的运行，结果如下：



在Person类中包含Man的引用，当Person被序列化的时候，从结果可以知道Man也被序列化了。
writeObject方法可以传入String，是因为String首先是一个类，其次它也是实现了Serializable接口的。
Person类中的age字段是transient，从打印结果可以看到，序列化Person person = new Person(man, "刘力", 21)对象时，age没有进行序列化。如果transient修饰的Object类型的，那么打印的结果将会是null。