最近做的项目中有一个模块需要填写页面上的表单，然后将表单的内容存入到MySQL数据库，下面将代码贴出来。

项目结构： 

数据库设计： 


3.各部分代码: 

package com.Interface:
package com.Interface;

import java.sql.Connection;
import java.sql.PreparedStatement;

import com.Util.DbUtil;
import com.model.Literature;

public class LiteratureInterface{
    public boolean addLiterature(Literature literature){
        String ChineseName=literature.getChineseName();
        String EnglishName=literature.getEnglishName();
        String Type=literature.getType();
        String Author=literature.getAuthor();
        String Source=literature.getSource();
        String ChineseAbstract=literature.getChineseAbstract();
        String EnglishAbstract=literature.getEnglishAbstract();
        String ChineseKeyword=literature.getChineseKeyword();
        String EnglishKeyword=literature.getEnglishKeyword();
        String ReforName=literature.getReforName();
        String Incentive=literature.getIncentive();
        String Content=literature.getContent();

        DbUtil db=new DbUtil();
        try {
            String sql="INSERT INTO wenxian(ChineseName,EnglishName,Type,Author,Source,ChineseAbstract,EnglishAbstract,ChineseKeyword,EnglishKeyword,ReforName,Incentive,Content) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)";
            Connection conn=db.getCon();
            PreparedStatement ps=conn.prepareStatement(sql);
            ps.setString(1, ChineseName);
            ps.setString(2, EnglishName);
            ps.setString(3, Type);
            ps.setString(4, Author);
            ps.setString(5, Source);
            ps.setString(6, ChineseAbstract);
            ps.setString(7, EnglishAbstract);
            ps.setString(8, ChineseKeyword);
            ps.setString(9, EnglishKeyword);
            ps.setString(10, ReforName);
            ps.setString(11, Incentive);
            ps.setString(12, Content);
            ps.executeUpdate();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return true;

    }
}

package com.model:



package com.model;

public class Literature {
    private String ChineseName;
    private String EnglishName;
    private String Type;
    private String Author;
    private String Source;
    private String ChineseAbstract;
    private String EnglishAbstract;
    private String ChineseKeyword;
    private String EnglishKeyword;
    private String ReforName;
    private String Incentive;
    private String Content;
    public String getChineseName() {
        return ChineseName;
    }
    public void setChineseName(String chineseName) {
        ChineseName = chineseName;
    }
    public String getEnglishName() {
        return EnglishName;
    }
    public void setEnglishName(String englishName) {
        EnglishName = englishName;
    }
    public String getAuthor() {
        return Author;
    }
    public void setAuthor(String author) {
        Author = author;
    }
    public String getSource() {
        return Source;
    }
    public void setSource(String source) {
        Source = source;
    }
    public String getChineseAbstract() {
        return ChineseAbstract;
    }
    public void setChineseAbstract(String chineseAbstract) {
        ChineseAbstract = chineseAbstract;
    }
    public String getEnglishAbstract() {
        return EnglishAbstract;
    }
    public void setEnglishAbstract(String englishAbstract) {
        EnglishAbstract = englishAbstract;
    }
    public String getChineseKeyword() {
        return ChineseKeyword;
    }
    public void setChineseKeyword(String chineseKeyword) {
        ChineseKeyword = chineseKeyword;
    }
    public String getEnglishKeyword() {
        return EnglishKeyword;
    }
    public void setEnglishKeyword(String englishKeyword) {
        EnglishKeyword = englishKeyword;
    }
    public String getReforName() {
        return ReforName;
    }
    public void setReforName(String reforName) {
        ReforName = reforName;
    }
    public String getIncentive() {
        return Incentive;
    }
    public void setIncentive(String incentive) {
        Incentive = incentive;
    }
    public String getContent() {
        return Content;
    }
    public void setContent(String content) {
        Content = content;
    }
    public String getType() {
        return Type;
    }
    public void setType(String type) {
        Type = type;
    }

}


package com.Util:



package com.Util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

   public class DbUtil {

    private String url="jdbc:mysql://localhost:3306/db-jsp";
    private String user="root";
    private String password="123";
    private String driver="com.mysql.jdbc.Driver";

    public Connection getCon() throws Exception{
                 Class.forName(driver);
                Connection con=DriverManager.getConnection(url, user, password);
                return con;

    }


    public static void getClose(Connection con) throws SQLException{
        if(con!=null){
            con.close();
        }

    }






}

package com.web:



package com.web;

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

import com.Interface.LiteratureInterface;
import com.Util.DbUtil;
import com.model.Literature;

public class PublishServlet extends HttpServlet {
    DbUtil db=new DbUtil();

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    /**
     * Constructor of the object.
     */
    public PublishServlet() {
        super();
    }

    /**
     * Destruction of the servlet. <br>
     */
    public void destroy() {
        super.destroy(); // Just puts "destroy" string in log
        // Put your code here
    }

    /**
     * The doGet method of the servlet. <br>
     *
     * This method is called when a form has its tag value method equals to get.
     * 
     * @param request the request send by the client to the server
     * @param response the response send by the server to the client
     * @throws ServletException if an error occurred
     * @throws IOException if an error occurred
     */
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {


    }

    /**
     * The doPost method of the servlet. <br>
     *
     * This method is called when a form has its tag value method equals to post.
     * 
     * @param request the request send by the client to the server
     * @param response the response send by the server to the client
     * @throws ServletException if an error occurred
     * @throws IOException if an error occurred
     */
    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        request.setCharacterEncoding("UTF-8");  
        response.setContentType("text/html;charset=UTF-8");

        String ChineseName=request.getParameter("ChineseName");
        String EnglishName=request.getParameter("EnglishName");
        String Type=request.getParameter("Type");
        String Author=request.getParameter("Author");
        String Source=request.getParameter("Source");
        String ChineseAbstract=request.getParameter("ChineseAbstract");
        String EnglishAbstract=request.getParameter("EnglishAbstract");
        String ChineseKeyword=request.getParameter("ChineseKeyword");
        String EnglishKeyword=request.getParameter("EnglishKeyword");
        String ReforName=request.getParameter("ReforName");
        String Incentive=request.getParameter("Incentive");
        String Content=request.getParameter("Content");

        Literature literature=new Literature();
        literature.setChineseName(ChineseName);
        literature.setEnglishName(EnglishName);
        literature.setType(Type);
        literature.setAuthor(Author);
        literature.setSource(Source);
        literature.setChineseAbstract(ChineseAbstract);
        literature.setEnglishAbstract(EnglishAbstract);
        literature.setChineseKeyword(ChineseKeyword);
        literature.setEnglishKeyword(EnglishKeyword);
        literature.setReforName(ReforName);
        literature.setIncentive(Incentive);
        literature.setContent(Content);

        LiteratureInterface literatureInter=new LiteratureInterface();
        literatureInter.addLiterature(literature);

        request.getRequestDispatcher("main.jsp").forward(request, response);
    }

    /**
     * Initialization of the servlet. <br>
     *
     * @throws ServletException if an error occurs
     */
    public void init() throws ServletException {
        // Put your code here
    }

}


index.jsp:



<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
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 'index.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>
   <form action="PublishServlet" method="post">
   <table>
       <tr>
          <td>文献中文名称：</td>
          <td><input type="text" name="ChineseName" value="${param.ChineseName}"></td>
       </tr>
       <tr>
          <td>文献英文名称：</td>
          <td><input type="text" name="EnglishName" value="${param.EnglishiName}"></td>
       </tr>
       <tr>
          <td>文献类型：</td>
          <td>
             <select name="Type">
                <option value="">请选择</option>
                <option value="学术论文">学术论文</option>
                <option value="硕士学位论文">硕士学位论文</option>
                <option value="博士学位论文">博士学位论文</option>
                <option value="教材">教材</option>
                <option value="专著">专著</option>
                <option value="网文">网文</option>
                <option value="报告">报告</option>
                <option value="文档">文档</option>
             </select>
          </td>
       </tr>
       <tr>
          <td>作者：</td>
          <td><input type="text" name="Author" value="${param.Author}"></td>
       </tr>
       <tr>
          <td>文献来源：</td>
          <td><input type="text" name="Source" value="${param.Source}"></td>
       </tr>
       <tr>
          <td>中文摘要：</td>
          <td><input type="text" name="ChineseAbstract" value="${param.ChineseAbstract}"></td>
       </tr>
       <tr>
          <td>英文摘要：</td>
          <td><input type="text" name="EnglishAbstract" value="${param.EnglishAbstract}"></td>
       </tr>
       <tr>
          <td>中文关键词：</td>
          <td><input type="text" name="ChineseKeyword" value="${param.ChineseKeyword}"></td>
       </tr>
       <tr>
          <td>英文关键词：</td>
          <td><input type="text" name="EnglishKeyword" value="${param.EnglishKeyword}"></td>
       </tr>
       <tr>
          <td>参考文献：</td>
          <td><input type="text" name="ReforName" value="${param.ReforName}"></td>
       </tr>
       <tr>
          <td>收集动机(因做哪个项目收集此文献)：</td>
          <td><input type="text" name="Incentive" value="${param.Incentive}"></td>
       </tr>
       <tr>
          <td>内容：</td>
          <td><textarea name="Content" >${param.Content}</textarea></td>
       </tr>
       <tr>
          <td>
           <input type="submit" value="提交">
          </td>
       </tr>

   </table>

   </form>
  </body>
</html>


main.jsp:

<%@ page language="java" import="java.util.*" pageEncoding="ISO-8859-1"%>
<%
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 'main.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>
    This is my JSP page. <br>
  </body>
</html>


administrator.jsp:



<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<%
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 'guanliyuan.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>
     <form action="PublishServlet" method="post">
   <table>
       <tr>
          <td>文献中文名称：</td>
          <td><input type="text" name="ChineseName" value="${param.ChineseName}"></td>
       </tr>
       <tr>
          <td>文献英文名称：</td>
          <td><input type="text" name="EnglishName" value="${param.EnglishiName}"></td>
       </tr>
       <tr>
          <td>作者：</td>
          <td><input type="text" name="Author" value="${param.Author}"></td>
       </tr>
       <tr>
          <td>文献来源：</td>
          <td><input type="text" name="Source" value="${param.Source}"></td>
       </tr>
       <tr>
          <td>中文摘要：</td>
          <td><input type="text" name="ChineseAbstract" value="${param.ChineseAbstract}"></td>
       </tr>
       <tr>
          <td>英文摘要：</td>
          <td><input type="text" name="EnglishAbstract" value="${param.EnglishAbstract}"></td>
       </tr>
       <tr>
          <td>中文关键词：</td>
          <td><input type="text" name="ChineseKeyword" value="${param.ChineseKeyword}"></td>
       </tr>
       <tr>
          <td>英文关键词：</td>
          <td><input type="text" name="EnglishKeyword" value="${param.EnglishKeyword}"></td>
       </tr>
       <tr>
          <td>参考文献：</td>
          <td><input type="text" name="ReforName" value="${param.ReforName}"></td>
       </tr>
       <tr>
          <td>收集动机(因做哪个项目收集此文献)：</td>
          <td><input type="text" name="Incentive" value="${param.Incentive}"></td>
       </tr>
       <tr>
          <td>内容：</td>
          <td><textarea name="Content" >${param.Content}</textarea></td>
       </tr>
       <tr>
          <td>
           <input type="submit" value="提交">
          </td>
       </tr>

   </table>

   </form>
  </body>
</html>


配置文件web.xml:



<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
  <display-name></display-name>
  <servlet>
    <description>This is the description of my J2EE component</description>
    <display-name>This is the display name of my J2EE component</display-name>
    <servlet-name>PublishServlet</servlet-name>
    <servlet-class>com.web.PublishServlet</servlet-class>
  </servlet>



  <servlet-mapping>
    <servlet-name>PublishServlet</servlet-name>
    <url-pattern>/PublishServlet</url-pattern>
  </servlet-mapping>

  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>


4.运行项目，首界面： 


点击提交后，再刷新数据库： 

一，简介和应用
Java中对线程局部存储进行支持的类是：

public class ThreadLocal<T>
extends Object
其文档解释为：
该类提供了线程局部 (thread-local) 变量。这些变量不同于它们的普通对应物，因为访问某个变量（通过其 get 或 set 方法）的每个线程都有自己的局部变量，它独立于变量的初始化副本。ThreadLocal 实例通常是类中的 private static 字段，它们希望将状态与某一个线程（例如，用户 ID 或事务 ID）相关联。
解释下这段话：
  1，该类提供“线程局部存储技术”。即尽管表面上，访问的都是这个类的get()方法和set()方法，但是不同的线程设置的和获取的数据是不同的。
  2，该类往往是作为其他类的private static字段存在，用以保持一个与线程本身有关的变量的。




方法摘要
 T
get()

          返回此线程局部变量的当前线程副本中的值。
protected  T
initialValue()

          返回此线程局部变量的当前线程的“初始值”。
 void
remove()

          移除此线程局部变量当前线程的值。
 void
set(T value)

          将此线程局部变量的当前线程副本中的值设置为指定值。


例如，任务类Task被作为线程池的任务执行，线程池的线程执行任务需要统计执行的线程数，因此，这个数可以作为线程局部存储的数据。


public class Task implements Runnable{


    private static final ThreadLocal threadLocal = new ThreadLocal();


    public void run() {


        Integer in = (Integer)threadLocal.get();


        if(in == null){

            //线程里没有该数据，说明是第一次执行

            threadLocal.set(new Integer(1));


        }else{

            //线程中有该数据，则应该进行更新

            threadLocal.set(in+1);


        }
        //执行任务的时候打印下目前已经有多少任务是由该线程执行的

        System.out.println(threadLocal.get().toString()+"  tasks are run by this thread. ");


   }


}



二，实现原理

  这种机制的实现其实很简单。类ThreadLocal中有个内部类ThreadLocalMap 其是 ThreadLocal 和 所设定的值的Key-Value键值对。 例如对于上述例子，第一次则对应的为 threadLocal -- Integer(1)。但是该ThreadLocalMap的实例，则存储于线程中，是线程类的成员变量。
 因此


  public T get() {  
        Thread t = Thread.currentThread();  
        ThreadLocalMap map = getMap(t);  
        if (map != null)  
            return (T)map.get(this);  
  
        // Maps are constructed lazily.  if the map for this thread  
        // doesn't exist, create it, with this ThreadLocal and its  
        // initial value as its only entry.  
        T value = initialValue();  
        createMap(t, value);  
        return value;  
    }
   
 ThreadLocalMap getMap(Thread t) {
        return t.threadLocals; 

   }    

如上源代码所示，get()方法先调用getMap(Thread t)方法获取线程的成员变量threadLocals，然后从这个threadLocals中以本ThreadLocal 实例为参数获取其值。
对应的set()方法：

    public void set(T value) {  
        Thread t = Thread.currentThread();  
        ThreadLocalMap map = getMap(t);  
        if (map != null)  
            map.set(this, value);  
        else  
            createMap(t, value);  
    }  

也是从线程中获取其成员变量然后去设置它的（如果没有则创建它，并设置第一个ThreadLocal-值 的映射）。



因此，实际上这个类都是从线程的成员变量中获取自己这个类的实例对应的值的。因此尽管类的参数相同，都是自己，但是不同线程导致数据来源不同，因此设置和获取都是线程自己的成员变量。

目录

•写在前面

•程序计数器

•java虚拟机栈和本地方法栈

•java堆

•方法区

•写在前面

Java虚拟机运行时数据区是我们深入了解JVM的必经之路，那这是什么样的一个区域呢？Java虚拟机在执行Java程序的过程中，会把它所管理的内存划分若干个不同的数据区域，这些区域被赋予不同的用途，它们有着各自创建和销毁时间，有的区域是随着虚拟机进程启动而存在的，有的区域则是依赖用户线程的启动和结束而建立和销毁的。它是类似一种模型规范，Java虚拟机的构建需要依照这个进行。我们可以把它大致的画成一个图，大概是长这样的。



关于线程隔离和线程共享的部分，接下来对几个数据区单独讲解的时候会详细说到，这里你只要大概了解他们存在隶属的单个线程的还是整个区域的。

•程序计数器

首先我们来谈一谈程序计数器，程序计数器这东西，它其实在不同的虚拟机中有不同的实现，毕竟相对于对程序独立计数的算法，往往有很多更加优化高效的算法可以使用，所以我们在这里提到的程序计数器的概念，是在虚拟机的内存模型中的，具体实现因不同虚拟机而异。在概念模型中，程序计数器是一块较小的内存空间，它可以看做是当前线程所执行的字节码的行号指示器，字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。

为了方便理解，我这里打开一个编译后的字节码文件，贴出来，你就会发现十六进制下，他们是一个寻址执行的过程（自己也可以去找一个class文件看看，记得别直接用记事本啥的打开哦会乱码的，可以使用winhex这个小工具打开）。



由于Java虚拟机的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的，在任何一个确定的时刻，一个处理器只能执行一条线程中的指令，因此，为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，各条线程之间计数器互不影响，独立储存，所以说程序计数器是“线程私有”的内存区。

要强调一下的是，线程在执行一个java方法，这个程序计数器记录的是正在执行的虚拟机字节码指令地址，就是上图我标记的内存偏移地址（指令地址），但如果执行的是一个native方法，则程序计数器为空，也就是undefined。而且程序计数器这块内存是唯一一个在java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。

•java虚拟机栈和本地方法栈

和程序计数器一样，java虚拟机栈同样也是线程私有的，它的生命周期和线程相同，虚拟机栈描述的是java方法执行的内存模型，这个模型大概这么描述：每个方法在执行的同时都会创建一个栈帧用于储存局部变量表、操作数栈、动态链接、方法出口等信息，每个方法从条用直至执行完成的过程，就是对应着一个栈帧在虚拟机栈中入栈到出栈的过程。

进一步了解，局部变量表存放了编译期可知的各种基本数据类型（就是boolean、int、float之类的这些）、对象引用（就是我们所说的reference类型，它是指向对象起始地址的引用指针，也可能是指向一个代表对象的句柄或者其他与此对象相关的位置）、returnAddress类型（指向了一条字节码指令的地址）。

基本数据类型中，long和double类型是64位长度，所以在局部变量表中占用2个空间，其余的数据只占一个。局部变量变所需的内存空间在编译期间就完成了分配，当进入一个方法是，这个方法需要在帧中分配多大的局部变量空间是确定的，方法运行期间不会改变局部变量表的大小。

对于java虚拟机栈，规定了两种异常状况，第一种是如果线程请求的栈深度大于虚拟机所允许的深度，将抛出Stack OverflowError异常。第二种是如果虚拟机栈可以动态扩展，而扩展是无法申请足够的内存，就会抛出OutOfMemoryError异常。

本地方法栈，之所以和虚拟机栈放在一起讲，是因为两个发挥的作用非常相似，它们之间的差别不过是虚拟机栈为虚拟机执行的java方法工作，而本地方发展执行的是Native方法工作（java方法和native方法东西挺多了，有兴趣看我另一篇文章，专门讲这两个东西）

•java堆

java堆应该是我们打交道最大的一块内存，和目前为止上面讲到的区域不同的是，java堆是一块所有线程共享的一块内存区域。在虚拟机启动时创建。这个内存的唯一目的就是用来存放对象实例，几乎所有的对象实例都放在这里分配内存，我们翻阅java虚拟机规范的时候，里面是这样描述的：所有对象的实例以及数组都要在堆上分配，但随着JIT编译器的发展与逃逸分析技术逐渐成熟，栈上分配、标量替换优化技术将会导致一些微妙的变化，所有的对象都是分配在堆上也渐渐变得不那么绝对。

正因为我们创建的所有实例都放在堆上分配，所以，虚拟机在进行垃圾回收的时候，主要也是针对java堆进行的，所以java堆也被成为GC堆。从内存回收的角度来看，由于现在收集器基本都采用分带收集算法，所以java堆还可以细分为新生代和老年代，更进一步就是一个E区和两个S区，关于分代涉及到GC算法，可以查阅我的另一篇文章，专门对GC算法进行详细的讲解。从内存分配的角度来看，线程共享的java堆中可能划分出多个线程私有的分配缓冲区，不过无论如何划分，都与存放内容没有关系，无论哪个区域，存放的都是对象实例

•方法区

同java堆一样，方法区也是线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。你去查案java虚拟机规范的时候会发现，里面把方法区描述为堆的一个逻辑部分，但它却又一个别名叫做Non-Heap（非堆），目的就是和java堆区分开。特别说明的是，方法区和java堆一样不需要连续的内存和可以选择固定大小或者可以扩展外，还可以不识闲垃圾回收。换一种确切的说法就是垃圾回收行为在这个区域是比较少出现的，但并非数据进入方法区就永久存在了（方法区已经被用来做永久代），这区域的内存回收目标主要是针对常量池的回收和对类型的卸载，一般来说这个区域的回收效果很难达到预期，毕竟里面存的都是些“老东西”，尤其是类型的卸载，条件相当的苛刻，但不管怎么说，还是需要进行垃圾回收的。

在方法区中有一个特别的部分，叫做运行时常量池。我们编译出来的Class文件中，除了有类的版本、字段、方法、接口等描述信息外，还有一项信息就叫做常量池，用来存放编译器生成的各种字面量和符号引用，这部分内容将在类加载进入方法区的运行时常量池中存放。

我们知道的，java虚拟机对Class文件的每一部分的格式都有严格的规定，每一个字节用于储存哪种数据都必须符合规范上的要求才能被虚拟机认可、装载和执行（上面的那个class文件的内容，你不要觉得它乱，其实它有着严格的格式）。但对于运行时常量池，java虚拟机规范中没有做任何细节的要求，不同的提供商的虚拟机有着不同的实现方式。不过一般来说，除了保存Class文件中描述的符号引用外，还会把翻译出来的直接引用也储存在运行时常量池中。运行时常量池相对于Class文件常量的另一个重要特征是具备动态性，java语言并不要求常量一定只要编译器才能产生，也就是并非预置入Class文件中常量池的内容才能进入方法区运行时常量池，运行期间也可能将新的常量放入池中，这种特性用到比较多的是String类的intern()方法。

在Android系统中提供了多张存储技术，这些存储技术可以讲数据保存在各种存储介质上。例如SharedPreferences可以将数据保存在应用软件的私有存储区，这些存储区中的数据只能被写入这些数据的软件读取。除此之外，Android系统还支持文件存储、SQLite数据库、OBB文件、云存储等

SharedPreferences的基本用法

SharedPreferences处理的就是一个key-value对。

它是一个轻量级的存储类，特别适合用于保存软件配置参数。使用SharedPreferences保存数 据，其背后是用xml文件存放数据，使用简易的键值对存储。



//文件命名为demo，私有模式
SharedPreferences sharedPreferences = getSharedPreferences("demo", Context.MODE_PRIVATE);
Editor editor = sharedPreferences.edit();//获取编辑器
editor.putString("name", "hello");
editor.putInt("age", 6);
editor.commit();//提交修改

这样，我们就把信息存储到了/data/data/<packagename>/shared_prefs/demo.xml文件里面，现在你打开这个文件，就可以看到内容已经被存储。如下：



<?xml version='1.0' encoding='utf-8' standalone='yes' ?>
<map>
<string name="name">hello</string>
<int name="age" value="6" />
</map>

getSharedPreferences(name,mode) 方法的第一个参数用于指定该文件的名称，最好定义为一个静态字符串，另外，名称如上面所示，不用带后缀名，后缀名会由系统自动加上。方法的第二个参数指定 文件的操作模式，共有四种操作模式，这四种模式想必大家都有一定的了解。这里简单说一下：

Type
  
Commens
MODE_PRIVATE
  
默认模式,在创建的文件只能该应用能够使用(或所有的应用程序共享同一个用户标识号)。
MODE_APPEND
  
如果文件已经存在，在文件内容后面添加。
MODE_WORLD_READABLE
  
允许其他应用读该应用创建的文件。
MODE_WORLD_WRITEABLE
  
允许其他应用写该应用创建的文件。
所以，如果你希望SharedPreferences背后使用的xml文件能被其他应用读和写，可以指定Context.MODE_WORLD_READABLE和Context.MODE_WORLD_WRITEABLE权限。

另外Activity还提供了另一个getPreferences(mode)方法操作SharedPreferences，这个方法默认使用当前类不带包名的类名作为文件的名称。

如果我们的模式设置为Context.MODE_WORLD_READABLE和Context.MODE_WORLD_WRITEABLE权限，我们其他的应用是可以访问的，下面是其他应用访问的代码（假如上面代码的包名为cn.test.demo）：



try{
 Context context = createPackageContext("cn.test.demo",  Context.CONTEXT_IGNORE_SECURITY);
} catch (NameNotFoundException e){
 e.printStackTrace();
}

CreatePackageContext这个方法有两个参数： 

1.packageName 包名，要得到Context的包名 

2.flags 标志位，有CONTEXT_INCLUDE_CODE和CONTEXT_IGNORE_SECURITY两个选项。 

CONTEXT_INCLUDE_CODE的意思是包括代码，也就是说可以执行这个包里面的代码。 
CONTEXT_IGNORE_SECURITY的意思 是忽略安全警告，如果不加这个标志的话，有些功能是用不了的，会出现安全警告。

CreatePackageContext方法在找不到包名的时候会报NameNotFoundException异常，所以我们要捕获它。

数据的存储位置和格式

文件存放在/data/data/<packagename> /shared_prefs目录下



存取复杂类型的数据

不建议使用，但是确实可以存储复杂类型的数据。

如果想用SharedPreferences存取更加复杂的数据类型（对象图像等），就需要对这些数据进行编码，通常会将复杂类型的数据转换成Base64格式的编码，然后将转换后的数据以字符串的形式保存在xml文件中。



效果图





说明

本例将一个Product对象和一个图像保存在xml文件中，并在程序重新运行后从xml文件装载Product和图像。



Code



Product.java




import java.io.Serializable;

/**
 * MyApp
 *
 * @author Mr.Yang on 2016-02-21  17:08.
 * @version 1.0
 * @desc  必须可序列化，需要实现Serializable
 */
public class Product implements Serializable
{
    public String name;
    public int price;
}


我们使用了存放在res/drawable中的图片，下面的代码将该图像保存在base64.xml文件中。



将该图像保存在base64.xml文件中。



 try {
            SharedPreferences sharedPreferences = getSharedPreferences("base64", Activity.MODE_PRIVATE);
            SharedPreferences.Editor editor = sharedPreferences.edit();

            // 读取和压缩R.drawable.item10,并将其压缩结果保存在ByteArrayOutputStream中
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            BitmapFactory.decodeResource(getResources(), R.drawable.item10).compress(Bitmap.CompressFormat.JPEG, 50, baos);
            // 对压缩后的字节进行Base6编码
            String imageBase64 = new String(Base64.encode(baos.toByteArray(), Base64.DEFAULT));
            // 保存转换后的Base64格式字符串
            editor.putString("image", imageBase64);
            editor.commit();
            // 关闭输出流
            baos.close();

            Toast.makeText(this, "onClick_Save_Image 成功", Toast.LENGTH_LONG).show();

        } catch (Exception e) {

        }



读取并显示在ImageView上



 try {
            SharedPreferences sharedPreferences = getSharedPreferences("base64", Activity.MODE_PRIVATE);
            // 读取Base64格式的图片数据
            String imageBase64 = sharedPreferences.getString("image", "");
            // 对Base64格式的字符串进行解码，还原成字节数组
            byte[] imageBytes = Base64.decode(imageBase64.getBytes(), Base64.DEFAULT);
            ByteArrayInputStream bais = new ByteArrayInputStream(imageBytes);
            // 在控件上显示图像
            ImageView imageView = (ImageView) findViewById(R.id.image);
            imageView.setImageDrawable(Drawable.createFromStream(bais, "image"));
            // 关闭输入流
            bais.close();

            Toast.makeText(this, "onClick_Read_Image 成功", Toast.LENGTH_LONG).show();


        } catch (Exception e) {

        }



将Product保存到base64.xml中



  try {
            Product product = new Product();

            product.name = "如来神掌";
            product.price = 1500;
            ByteArrayOutputStream baos = new ByteArrayOutputStream();

            ObjectOutputStream oos = new ObjectOutputStream(baos);
            // 将Product对象保存到ObjectOutputStream中
            oos.writeObject(product);

            SharedPreferences sharedPreferences = getSharedPreferences("base64", Activity.MODE_PRIVATE);
            SharedPreferences.Editor editor = sharedPreferences.edit();
            // 将Product对象转换成byte数组，并将其进行Base64编码
            String productBase64 = new String(Base64.encode(baos.toByteArray(), Base64.DEFAULT));
            // 将编码后的字符串保存到base64.xml中
            editor.putString("product", productBase64);
            editor.commit();
            // 输出流关闭
            oos.close();

            Toast.makeText(this, "onClick_Save_Serializable_Object 成功", Toast.LENGTH_LONG).show();
        } catch (Exception e) {

        }



从base64.xml中读取Product对象



 try {
            SharedPreferences sharedPreferences = getSharedPreferences("base64", Activity.MODE_PRIVATE);
            // 读取Product对象的Base64格式的字符串
            String base64Product = sharedPreferences.getString("product", "");

            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            //将base64格式字符串还原成byte数组
            byte[] productBytes = Base64.decode(base64Product.getBytes(), Base64.DEFAULT);
            ByteArrayInputStream bais = new ByteArrayInputStream(productBytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            // 将byte数组转换成Product对象
            Product product = (Product) ois.readObject();
            Toast.makeText(this,
                    "name:" + product.name + "\nprice：" + product.price,
                    Toast.LENGTH_LONG).show();
            // 关闭输入流
            ois.close();

        } catch (Exception e) {

        }

设置数据文件的访问权限



 /**
     * MODE_WORLD_READABLE  MODE_WORLD_READABLE
     * "This constant was deprecated in API level 17.
     * Creating world-readable files is very dangerous,
     * and likely to cause security holes in applications.
     * It is strongly discouraged; instead,
     * applications should use more formal mechanism for interactions
     * such as ContentProvider, BroadcastReceiver, and Service.
     * There are no guarantees that this access mode will remain on a file,
     * such as when it goes through a backup and restore.
     * File creation mode: allow all other applications to have read access to the created file."
     */
    private void createDiffPermissionSpFile() {

        int[] modes = new int[]{Activity.MODE_PRIVATE, Activity.MODE_APPEND,
                Activity.MODE_WORLD_READABLE,
                Activity.MODE_WORLD_READABLE};

        for (int i = 0; i < modes.length; i++) {

            SharedPreferences sharedPreferences = getSharedPreferences("data" + String.valueOf(i + 1), modes[i]);
            SharedPreferences.Editor editor = sharedPreferences.edit();
            editor.putString("name", "不同的访问权限");
            editor.commit();

        }
    }

观察生成的文件的权限，同linux文件系统



可以保存设置的Activity：PreferenceActivity



概述

Android SDK提供了更加方便的方法来实现配置界面，并且可以透明的保存配置信息，这就是PreferenceActivity.

PreferenceActivity是Activity的子类，该类封装了SharedPreference，因此PreferenceActivity的所有子类都会拥有保存key-value的能力。

通过PreferenceActivity生成的XML文件在data/data/<工程名>/shared_prefs/下，名字为“<工程名>_Preference.xml。

在PreferenceActivity中，所有的修改都会自动更新该XML文件，不需要我们手动去设置大量的监听。

PreferenceActivity提供了一些常用的控件，可以满足大多数配置界面的要求， PreferenceActivity既可以从xml文件中创建，也可以通过代码的方式创建。

比较常用的控件有3个：

CheckBoxPreference:对应<CheckBoxPreference>标签，相当于CheckBox
EditTextPreference：对应<EditTextPreference>标签。单击该控件会弹出一个带有EditText的对话框
ListPreference:对应<ListPreference>标签，单击该控件会弹出一个带ListView的对话框。
效果图



PreferenceActivity在API11之后就废弃了，建议使用PreferenceFragment。



res目录下创建一个xml子目录，建立preference_setting.xml



<?xml version="1.0" encoding="utf-8"?>
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android" >

    <PreferenceCategory android:title="我的位置源" >
        <CheckBoxPreference
            android:key="wireless_network"
            android:summary="使用无线网络查看应用程序（例如Google地图）中的位置"
            android:title="使用无线网络" />
        <CheckBoxPreference
            android:key="gps_satellite_setting"
            android:summary="定位时，精确到街道级别（取消选择可节约电量）"
            android:title="启用GPS卫星设置" />
    </PreferenceCategory>


    <PreferenceCategory android:title="个人信息设置" >
        <CheckBoxPreference
            android:key="yesno_save_individual_info"
            android:title="是否保存个人信息" />

        <EditTextPreference
            android:key="individual_name"
            android:summary="请输入真实姓名"
            android:title="姓名" />

        <PreferenceScreen
            android:key="other_individual_msg"
            android:summary="是否工作、手机"
            android:title="其他个人信息" >
            <CheckBoxPreference
                android:key="is_an_employee"
                android:title="是否工作" />

            <EditTextPreference
                android:key="mobile"
                android:summary="请输入真实的手机号"
                android:title="手机" />
        </PreferenceScreen>
    </PreferenceCategory>

</PreferenceScreen>



PreferenceActivityDemo

package com.turing.base.activity.dataStore.sharedPreference;

import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.Preference;
import android.preference.PreferenceActivity;
import android.preference.PreferenceScreen;

import com.turing.base.R;

/**
 *   3.0版本以后就需要使用PreferenceFragment，这里用过时的也没关系
 */
public class PreferenceActivityDemo extends PreferenceActivity implements Preference.OnPreferenceChangeListener {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 改变保存数据的xml使用的名称，默认是<package_name>_preferences.xml
        getPreferenceManager().setSharedPreferencesName("setting");
        // 从xml文件中加载布局
        addPreferencesFromResource(R.xml.preference_setting);
        // 获取"姓名"列表项对应的Preference对象
        Preference individualNamePreference = findPreference("individual_name");
        // 获得指向setting.xml文件的SharedPreferences对象
        SharedPreferences sharedPreferences = individualNamePreference.getSharedPreferences();
        // 设置列表项的Summary
        individualNamePreference.setSummary(sharedPreferences.getString("individual_name", ""));
        //设置"姓名"列表项是否可用
        if (sharedPreferences.getBoolean("yesno_save_individual_info", false))
            individualNamePreference.setEnabled(true);
        else
            individualNamePreference.setEnabled(false);
        // 设置包含onPreferenceChange事件的对象实例
        individualNamePreference.setOnPreferenceChangeListener(this);

        //mobile

        // 获取"mobile"列表项对应的Preference对象
        Preference mobilePreference = findPreference("mobile");
        // 获得指向setting.xml文件的SharedPreferences对象
        SharedPreferences mobileSP = mobilePreference.getSharedPreferences();
        // 设置列表项的Summary
        mobilePreference.setSummary(mobileSP.getString("mobile", ""));
        // 设置包含onPreferenceChange事件的对象实例
        mobilePreference.setOnPreferenceChangeListener(this);

    }

    @Override
    public boolean onPreferenceChange(Preference preference, Object newValue) {
        // 设置"姓名"列表项中Summary的值
        preference.setSummary(String.valueOf(newValue));
        // 必须返回为true，否则无法保存设置的值
        return true;
    }

    /**
     * 状态改变后的自动文件存储 需要继承PreferenceActivity的类和实现OnPreferenceChangeListener接口,
     * 重写onPreferenceTreeClick方法进行业务逻辑处理
     * @param preferenceScreen
     * @param preference
     * @return
     */
    @Override
    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,Preference preference) {
        // 判断选中的是否为"是否保存个人信息"列表项的复选框
        if ("yesno_save_individual_info".equals(preference.getKey())) {
            // 设置姓名为可选或者不可选
            findPreference("individual_name").setEnabled(!findPreference("individual_name").isEnabled());
        }
        return super.onPreferenceTreeClick(preferenceScreen, preference);
    }
}