学习笔记

一、tomcat

1. Servlet（Server Applet），全称Java Servlet，未有中文译文。是用Java编写的服务器端程序

2. Java服务器页面（JSP）是HttpServlet的扩展。由于HttpServlet大多是用来响应HTTP请求，并返回Web页面（例如HTML、XML），所以不可避免地，在编写servlet时会涉及大量的HTML内容，这给servlet的书写效率和可读性带来很大障碍，JSP便是在这个基础上产生的。其功能是使用HTML的书写格式，在适当的地方加入Java代码片断，将程序员从复杂的HTML中解放出来，更专注于servlet本身的内容

3. JSP在首次被访问的时候被应用服务器转换为servlet，在以后的运行中，容器直接调用这servlet，而不再访问JSP页面。JSP的实质仍然是servlet。

    Tomcat 4.x

• Servlet容器被重新设计，并被命名为Catalina

• JSP引擎被重新设计，并被命名为Jasper

1. 实际上Tomcat 部分是Apache 服务器的扩展，但它是独立运行的，所以当你运行tomcat 时，它实际上作为一个与Apache独立的进程单独运行的。当配置正确时，Apache 为HTML页面服务，而Tomcat 实际上运行JSP 页面和Servlet。另外，Tomcat和IIS、Apache等Web服务器一样，具有处理HTML页面的功能，另外它还是一个Servlet和JSP容器，独立的Servlet容器是Tomcat的默认模式。不过，Tomcat处理静态HTML的能力不如Apache服务器。

2. 与传统的桌面应用程序不同，Tomcat中的应用程序是一个WAR（Web Archive）文件。WAR是Sun提出的一种Web应用程序格式，与JAR类似，也是许多文件的一个压缩包。

1. 这个包中的文件按一定目录结构来组织：通常其根目录下包含有Html和Jsp文件或者包含这两种文件的目录，另外还会有一个WEB-INF目录，这个目录很重要。通常在WEB-INF目录下有一个web.xml文件和一个classes目录，web.xml是这个应用的配置文件，而classes目录下则包含编译好的Servlet类和Jsp或Servlet所依赖的其它类（如JavaBean）。通常这些所依赖的类也可以打包成JAR放到WEB-INF下的lib目录下，当然也可以放到系统的CLASSPATH中，但那样移植和管理起来不方便。

2. 所有需要的class文件均以WEB-INF/classes/为根目录按包名存放 ，所有的jar文件全部放在WEB-INF/lib下 ，Web服务器 （比如Tomcat）会自动把classes和lib下的所有jar文件动态添加到CLASSPATH中，其中classes目录优先级高，如果 classes和lib中某个jar的class全名相同，则只会找到classes下的文件

3. WEB-INF/web.xml是标准配置文件 ，负责注册Servlet，Filter及其它用到的资源。如果没有web.xml，Tomcat会使用缺省的配置文件（什么也不配置）。如果有web.xml,Tomcat 会首先访问它。

4. 一般说来，自己写的class包括servlets，filter，javaBean等编译后放在classes目录下，用到的第三方jar（如struts.jar）放在lib下

5. 只有具有这种结构的war文件就可以直接在任何服务器下部署，jboss支持热部署，tomcat则要重启

• tomcat - 程序部署

1. 在Tomcat中，应用程序的部署很简单，你只需将你的WAR放到Tomcat的webapp目录下，Tomcat会自动检测到这个文件，并将其解压。你在浏览器中访问这个应用的Jsp时，通常第一次会很慢，因为Tomcat要将Jsp转化为Servlet文件，然后编译。编译以后，访问将会很快。另外Tomcat也提供了一个应用：manager，访问这个应用需要用户名和密码，用户名和密码存储在一个xml文件中。通过这个应用，辅助于Ftp，你可以在远程通过Web部署和撤销应用。当然本地也可以。

2. Tomcat不仅仅是一个Servlet容器，它也具有传统的Web服务器的功能：处理Html页面。但是与Apache相比，它的处理静态Html的能力就不如Apache.可以将Tomcat和Apache集成到一块，让Apache处理静态Html，而Tomcat处理Jsp和Servlet.这种集成只需要修改一下Apache和Tomcat的配置文件即可。

3. Tomcat提供Realm支持。Realm类似于Unix里面的group.在Unix中，一个group对应着系统的一定资源，某个group不能访问不属于它的资源。Tomcat用Realm来对不同的应用（类似系统资源）赋给不同的用户（类似group）。没有权限的用户则不能访问这个应用。Tomcat提供三种Realm，1：JDBCRealm，这个Realm将用户信息存在数据库里，通过JDBC获得用户信息来进行验证。2：JNDIRealm，用户信息存在基于LDAP的服务器里，通过JNDI获取用户信息。3：MemoryRealm，用户信息存在一个xml文件里面，上面讲的manager应用验证用户时即使用此种Realm.通过Realm可以方便地对访问某个应用的客户进行验证。

        补充：大话JNDI

        JNDI全称 Java Naming and Directory Interface

        1、JNDI 提出的目的是为了解藕，是为了开发更加容易维护，容易扩展，容易部署的应用
        2、JNDI 是一个sun提出的一个规范(类似于jdbc),具体的实现是各个j2ee容器提供商，sun只是 要求，j2ee容器必须有JNDI这样的功能
        3、JNDI 在j2ee系统中的角色是“交换机”，是J2EE组件在运行时间接地查找其他组件、资源或 服务的通用机制。
        4、JNDI 是通过资源的名字来查找的，资源的名字在整个j2ee应用中(j2ee容器中)是唯一的。

1. 在Tomcat4中，你还可以利用Servlet2.3提供的事件监听器功能，来对你的应用或者Session实行监听。Tomcat也提供其它的一些特征，如与SSL集成到一块，实现安全传输。还有Tomcat也提供JNDI支持，这与那些J2EE应用服务器提供的是一致的。说到这里要介绍一下通常所说的应用服务器（如WebLogic）与Tomcat有何区别。应用服务器提供更多的J2EE特征，如EJB，JMS，JAAS等，同时也支持Jsp和Servlet.而Tomcat则功能没有那么强大，它不提供EJB等支持。但如果与JBoss（一个开源的应用服务器）集成到一块，则可以实现J2EE的全部功能。

2. 基于Tomcat的开发其实主要是Jsp和Servlet的开发，开发Jsp和Servlet非常简单，你可以用普通的文本编辑器或者IDE，然后将其打包成WAR即可。这里要提到另外一个工具Ant，Ant也是Jakarta中的一个子项目，它所实现的功能类似于Unix中的make。你需要写一个build.xml文件，然后运行Ant就可以完成xml文件中定义的工作，这个工具对于一个大的应用来说非常好，只需在xml中写很少的东西就可以将其编译并打包成WAR。在很多应用服务器的发布中都包含了Ant.

3. CATALINA_HOME和CATALINA_BASE的区别。简单的说，CATALINA_HOME是Tomcat的安装目录，CATALINA_BASE是Tomcat的工作目录。如果我们想要运行Tomcat的 多个实例，但是不想安装多个Tomcat软件副本。那么我们可以配置多个工作目录，每个运行实例独占一个工作目录，但是共享同一个安装目录。

4. Tomcat每个运行实例需要使用自己的conf、logs、temp、webapps、work和shared目录，因此CATALINA_BASE就指向这些目录。 而其他目录主要包括了Tomcat的二进制文件和脚本，CATALINA_HOME就指向这些目录。如果我们希望再运行另一个Tomcat实例，那么我们可以建立一个目录，把conf、logs、temp、webapps、work和shared拷贝到该目录下，然后让CATALINA_BASE指向该目录即可。

5. 在一台服务器上，可以运行多个tomcat实例，不需要安装多个tomcat，可以采用不同的用户，以test用户为例，拷贝/usr/local/apache-tomcat- 6.0.18目录到/home/test下，删除/home/test/apache-tomcat-6.0.18/bin子目录（此目录不需要），编辑 /home/test/.bash_profile文件,设置CATALINA_HOME指向刚才的安装目录/usr/local/apache- tomcat-6.0.18,设置JAVA_HOME指向刚才的安装目录/usr/java/jdk1.6.0_11。设置CATALINA_BASE指 向/home/test/apache-tomcat-6.0.18，设置CATALINA_OPTS跟/root/.bash_profile的一致 （jmx管理端口用不同的端口号）

6. tomcat的主目录文件夹有以下几个：

          1. bin：用于存放启动和关闭tomcat的可执行文件。

          2. lib：里面存放需要的jar包。

          3. conf：tomcat的各种配置文件，tomcat启动时需要读取的配置文件主要有：

                   server.xml，web.xml，tomcat-users.xml等等。服务器的修改都要从此目录中进行。

          4. logs：日志文件，如果服务器出现错误，会自动记录。

          5. server：服务器的管理程序。

          6. webapps：所有的可执行的web项目都会放到此目录中。

          7. work：tomcat把各种由jsp生成的servlet都放在了这个文件夹下，里面包含.java文件

                   和.class文件。

        

• 配置一个虚拟目录：

       1.要配置一个虚拟目录必须有以下的目录结构：

           WEB ROOT--->这是web根目录，可任意定义，一般的可执行.jsp文件都放在此文件夹中。    

               | WEB-INF ---> 虚拟目录必须有此文件夹，格式要求。

                   | web.xml 虚拟目录的配置文件。

       2.虚拟目录中的web.xml文件可以在文件夹webapps->ROOT->WEB-INF->web.xml找到。

       3.要想让tomcat启动时找到虚拟目录，需要在conf文件夹下的server.xml中进行配置。

          <Context path="/demo" docBase="D:\xnml"/>    此句必须写在</host>之上；

                 Context：表示配置一个新的上下文；

                 path：浏览器的输入路径，注意必须有 “/”；

                 docBase：path路径对应着硬盘上的真实目录；xnml文件夹也是web根目录；

        4.在conf文件夹中的web.xml文件中，ctrl+F 搜索list到

<init-param>
      <param-name>listings</param-name>
      <param-value>true</param-value>
</init-param>

          有的时候为false，改成true，意思是tomcat在加载时将目录列表功能打开，我们才可以访问虚 

          拟目录中的文件；

         5.在D:\xnml下写个.jsp文件；

         6.在浏览器中输入：http://localhost:8080/demo  tomcat启动时会执行配置文件进而执行.jsp文件。

• tomcat的执行流程：

        1.用户在浏览器中输入请求地址；

        2.客户端通过浏览器将请求地址发送给WEB容器；

        3.WEB容器根据请求地址找到*.jsp文件；

        4.将*.jsp文件转换成*.java文件；

        5.将*.java文件经过编译成*.class文件；

        6.服务器执行*.class文件并将结果反馈给浏览器。

1. Tomcat服务器是由一系列可配置的组件构成，其核心组件是Catalina Servlet容器，它是所有其他Tomcat组件的顶层容器。Tomcat的组件可以在<CATALINA_HOME>/conf/server.xml文件中进行配置,每个Tomcat的组件在server.xml文件中对应一种配置元素.一下代码以XML的形式展示了各种Tomcat组件之间的关系:

<Server>元素
    代表了整个Catalina   Servlet容器,它是Tomcat实例的顶层元素.可包含一个或多个<Service>元素.
<Service>元素
    包含一个<Engine>元素,以及一个或多个<Connector>元素,这些<Connector>元素共享同一个<Engine>元素.
<Connector>元素
    代表和客户程序实际交互的组件,他负责接收客户请求,以及向客户返回响应结果.
<Engine>元素
    每个<Service>元素只能包含一个<Engine>元素.   <Engine>元素处理在同一个<Service>中所有<Connector>元素接收到的客户请求.
<Host>元素
    一个<Engine>元素中可以包含多个<Host>元素.每个<Host>元素定义了一个虚拟主机,它可以包含一个或多个Web应用.
<Context>元素
    每个<Context>元素代表了运行虚拟主机上的单个Web应用.一个<Host>元素中可以包含多个<Context>元素.

元素名	属性	解释
server	port	指定一个端口，这个端口负责监听关闭tomcat 的请求
shutdown	指定向端口发送的命令字符串
service	name	指定service 的名字
Connector ( 表示客户端和service 之间的连接)	port	指定服务器端要创建的端口号，并在这个断口监听来自客户端的请求
minProcessors	服务器启动时创建的处理请求的线程数
maxProcessors	最大可以创建的处理请求的线程数
enableLookups	如果为true ，则可以通过调用request.getRemoteHost() 进行DNS 查询来得到远程客户端的实际主机名，若为false 则不进行DNS 查询，而是返回其ip 地址
redirectPort	指定服务器正在处理http 请求时收到了一个SSL 传输请求后重定向的端口号
acceptCount	指定当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理
connectionTimeout	指定超时的时间数( 以毫秒为单位)
Engine ( 表示指定service 中的请求处理机，接收和处理来自Connector 的请求)	defaultHost	指定缺省的处理请求的主机名，它至少与其中的一个host 元素的name 属性值是一样的
Context ( 表示一个web 应用程序，通常为WAR 文件，关于WAR 的具体信息见servlet 规范)	docBase	应用程序的路径或者是WAR 文件存放的路径
path	表示此web 应用程序的url 的前缀，这样请求的url 为http://localhost:8080/path/****
reloadable	这个属性非常重要，如果为true ，则tomcat 会自动检测应用程序的/WEB-INF/lib 和/WEB-INF/classes 目录的变化，自动装载新的应用程序，我们可以在不重起tomcat 的情况下改变应用程序
host ( 表示一个虚拟主机 )	name	指定主机名
appBase	应用程序基本目录，即存放应用程序的目录
unpackWARs	如果为true ，则tomcat 会自动将WAR 文件解压，否则不解压，直接从WAR 文件中运行应用程序
Logger ( 表示日志，调试和错误信息)	className	指定logger 使用的类名，此类必须实现org.apache.catalina.Logger 接口
prefix	指定log 文件的前缀
suffix	指定log 文件的后缀
timestamp	如果为true ，则log 文件名中要加入时间，如下例:localhost_log.2001-10-04.txt
Realm ( 表示存放用户名，密码及role 的数据库)	className	指定Realm 使用的类名，此类必须实现org.apache.catalina.Realm 接口
Valve ( 功能与Logger 差不多，其prefix 和suffix 属性解释和Logger 中的一样)	className	指定Valve 使用的类名，如用org.apache.catalina.valves.AccessLogValve 类可以记录应用程序的访问信息
directory	指定log 文件存放的位置
pattern	有两个值，common 方式记录远程主机名或ip 地址，用户名，日期，第一行请求的字符串，HTTP 响应代码，发送的字节数。combined 方式比common 方式记录的值更多

• 配置solr home 有三种方法可以配置solr home，任选一种即可： 

1,直接修改JAVA全局环境变量：(适用于该机器只有一个Solr实例)

    

1	export JAVA_OPTS="$JAVA_OPTS -Dsolr.solr.home=/home/du/softwore/solrhome"

2,修改TOMCAT_HOME/bin/catalina.sh,在文件开头添加：JAVA_OPTS=’-Dsolr.solr.home=/home/du/softwore/solrhome’;

1	# vi /usr/local/apache-tomcat-7.0.42/bin/catalina.sh
2	export JAVA_OPTS="$JAVA_OPTS -Dsolr.solr.home=/home/du/softwore/solrhome"

3,创建solr.xml文件放于TOMCAT_HOME/conf/Catalina/localhost，内容如下： 可能会目录不存在，其实启动一下tomcat，目录就会有了，也可以自己创建

1	# vi /usr/local/apache-tomcat-7.0.42/conf/Catalina/localhost/solr.xml

<?xml version="1.0" encoding="utf-8"?>
<Context docBase="TOMCAT_HOME/webapps/solr.war" debug="0" crossContext="true">
   <Environment name="solr/home" type="java.lang.String" value="/home/du/softwore/solrhome" override="true"/>
</Context>

二、Spring-MVC

1. 定义控制器

   简介：spring内建了一个请求驱动的web mvc框架，以一个servlet分发器为中心，将web请求分发到各个不同的处理器进行处理（这点和struts很相似）。这个servlet就是spring提供的DispatcherServlet，它必须在web.xml里配置。当然web.xml里可以配置多个DispatcherServlet，每个DispatcherServlet都会加载和自己相关的web应用上下文（即和应用相关的xml文件）

2. 控制器：
   Spring将web控制器视为普通的java对象，因此它可以在web上下文里配置，这就意味着他能够和整个spring容器无缝整合，并可以受益spring带来的一切优势。
   Controller接口：Spring默认的核心控制器被抽象为一个简单的控制器接口Controller，该接口仅定义了一种方法handleRequest(request,response)，直接实现了该接口的控制器具有最简单的功能，比如一个页面不需要表单的时候，他就可以实现给接口具有了控制器的功能来处理一些业务。
   AbstractController抽象控制器基类：
   该类定制了一些基本的web控制器功能，spring还提供了一些web控制器的基类，这些类都继承与该类
   AbstractCommandController命令控制器抽象基类：
   该类提供了一些基本的命令模板方法，允许直接继承并使用它。Spring还提供了一些很好的命令控制器基类（Command Controller），他们都继承于AbstractController
   AbstractFormController抽象的表单控制器：
   该类有功能非常强大也是最常用的两个子类：普通表单控制器SimpleFormController和向导式表单控制器AbstractWizardFormController

3. @Controller注解能将任意的类标注成控制器类。与传统的控制器相反，被标注的控制器类不需要实现特定于框架的接口，也不必扩展特定于框架的基类。

4. Controller接口是所有控制器接口的父类。所有Spring框架提供的控制器，以及所有用户自定义的控制器都得实现这个接口。

5. Spring 2.5 引入了 @Autowired 注释，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。

6. 这样，当 Spring 容器启动时，AutowiredAnnotationBeanPostProcessor 将扫描 Spring 容器中所有 Bean，当发现 Bean 中拥有@Autowired 注释时就找到和其匹配（默认按类型匹配）的 Bean，并注入到对应的地方中去。

7. 按照上面的配置，Spring 将直接采用 Java 反射机制对 Boss 中的 car 和 office 这两个私有成员变量进行自动注入。所以对成员变量使用 @Autowired 后，您大可将它们的 setter 方法（setCar() 和 setOffice()）从 Boss 中删除。

8. @Qualifier("office") 中的 office 是 Bean 的名称，所以 @Autowired 和 @Qualifier 结合使用时，自动注入的策略就从 byType 转变成 byName 了。@Qualifier 只能和 @Autowired 结合使用，是对 @Autowired 有益的补充。

9. @Resource 的作用相当于 @Autowired，只不过 @Autowired 按 byType 自动注入，面 @Resource 默认按 byName 自动注入罢了。@Resource 有两个属性是比较重要的，分别是 name 和 type，Spring 将 @Resource 注释的 name 属性解析为 Bean 的名字，而 type 属性则解析为 Bean 的类型。所以如果使用 name 属性，则使用 byName 的自动注入策略，而使用 type 属性时则使用 byType 自动注入策略。如果既不指定 name 也不指定 type 属性，这时将通过反射机制使用 byName 自动注入策略。

10. 我们知道，不管是通过实现 InitializingBean/DisposableBean 接口，还是通过 <bean> 元素的 init-method/destroy-method 属性进行配置，都只能为 Bean 指定一个初始化 / 销毁的方法。但是使用 @PostConstruct 和 @PreDestroy 注释却可以指定多个初始化 / 销毁方法，那些被标注 @PostConstruct 或 @PreDestroy 注释的方法都会在初始化 / 销毁时被执行。

11. <context:annotationconfig/> 将隐式地向 Spring 容器注册AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、PersistenceAnnotationBeanPostProcessor 以及equiredAnnotationBeanPostProcessor 这 4 个 BeanPostProcessor。

12. Spring 2.5 中除了提供 @Component 注释外，还定义了几个拥有特殊语义的注释，它们分别是：@Repository、@Service 和@Controller。在目前的 Spring 版本中，这 3 个注释和 @Component 是等效的，但是从注释类的命名上，很容易看出这 3 个注释分别和持久层、业务层和控制层（Web 层）相对应。虽然目前这 3 个注释和 @Component 相比没有什么新意，但 Spring 将在以后的版本中为它们添加特殊的功能。所以，如果 Web 应用程序采用了经典的三层分层结构的话，最好在持久层、业务层和控制层分别采用@Repository、@Service 和 @Controller 对分层中的类进行注释，而用 @Component 对那些比较中立的类进行注释。

13. 是否有了这些 IOC 注释，我们就可以完全摒除原来 XML 配置的方式呢？答案是否定的。有以下几点原因：

    1). 注释配置不一定在先天上优于 XML 配置。如果 Bean 的依赖关系是固定的，（如 Service 使用了哪几个 DAO 类），这种配置信息不会在部署时发生调整，那么注释配置优于 XML 配置；反之如果这种依赖关系会在部署时发生调整，XML 配置显然又优于注释配置，因为注释是对 Java 源代码的调整，您需要重新改写源代码并重新编译才可以实施调整。

    2). 如果 Bean 不是自己编写的类（如 JdbcTemplate、SessionFactoryBean 等），注释配置将无法实施，此时 XML 配置是唯一可用的方式。

    3). 注释配置往往是类级别的，而 XML 配置则可以表现得更加灵活。比如相比于 @Transaction 事务注释，使用 aop/tx 命名空间的事务配置更加灵活和简单。

    所以在实现应用中，我们往往需要同时使用注释配置和 XML 配置，对于类级别且不会发生变动的配置可以优先考虑注释配置；而对于那些第三方类以及容易发生调整的配置则应优先考虑使用 XML 配置。

    合理地使用 Spring 2.5 的注释配置，可以有效减少配置的工作量，提高程序的内聚性。但是这并不意味着传统 XML 配置将走向消亡，在第三方类 Bean 的配置，以及那些诸如数据源、缓存池、持久层操作模板类、事务管理等内容的配置上，XML 配置依然拥有不可替代的地位。

14. 简单的Java对象（Plain Old Java Objects）实际就是普通JavaBeans。

    使用POJO名称是为了避免和 EJB混淆起来, 而且简称比较直接. 其中有一些属性及其getter setter方法的类,没有业务逻辑，有时可以作为 VO(value -object)或 dto(Data Transform Object)来使用.当然,如果你有一个简单的运算属性也是可以的,但不允许有业务方法,也不能携带有connection之类的方法。 

15. JavaBean 是一种JAVA语言写成的可重用组件。为写成JavaBean，类必须是具体的和公共的，并且具有无参数的构造器。JavaBeans 通过提供符合一致性设计模式的公共方法将内部域暴露称为属性。众所周知，属性名称符合这种模式，其他Java 类可以通过自省机制发现和操作这些JavaBean 属性。

16. Spring还支持使用@Configuration，把一个类作为一个IoC容器，它的某个方法头上如果注册了@Bean，就会作为这个Spring容器中的Bean。

17. Spring使用的AOP注解分为三个层次：

    1、@Aspect放在类头上，把这个类作为一个切面，但是这个类一定要显式的注册在Spring容器中。

    2、@Pointcut放在方法头上，定义一个可被别的方法引用的切入点表达式。

    3、5种通知。

1. 3.1、@Before，前置通知，放在方法头上。

   3.2、@After，后置【finally】通知，放在方法头上。

   3.3、@AfterReturning，后置【try】通知，放在方法头上，使用returning来引用方法返回值。

   3.4、@AfterThrowing，后置【catch】通知，放在方法头上，使用throwing来引用抛出的异常。

   3.5、@Around，环绕通知，放在方法头上，这个方法要决定真实的方法是否执行，而且必须有返回值。

18. 自动注入需要使用@Value注解，这个注解的格式#{configProperties['mysql.url']}其中configProperties是我们在appContext.xml中配置的beanId，mysql.url是在properties文件中的配置项。

19. 1. 问题：

    创建MVC控制器的时候，不想硬编码字段的值，而是想赋一个出现在Bean文件或者是属性资源文件（message.properties)中的值。

    2.解决方法：

    用@Value注解使得Spring的MVC控制器中相关的字段能够使用Spring表达式语言SpEL进行赋值。你可以使用@Value注解和SpEL一起，查询应用上下文中的bean,取到相关的值。

20. 依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。具体含义是:当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，在 传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，因此称为控制反转;创建被调用者 实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。

21. 依赖注入通常有两种:
    

        设值注入。
        构造注入。

1. JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。 易于人阅读和编写。同时也易于机器解析和生成。

2. JSON建构于两种结构：
   

   “名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组 （associative array）。

   值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）。

   这些都是常见的数据结构。事实上大部分现代计算机语言都以某种形式支持它们。这使得一种数据格式在同样基于这些结构的编程语言之间交换成为可能。

3. JSON具有以下这些形式：

   对象是一个无序的“‘名称/值’对”集合。一个对象以“{”（左括号）开始，“}”（右括号）结束。每个“名称”后跟一个“:”（冒号）；“‘名称/值’ 对”之间使用“,”（逗号）分隔。

   

   数组是值（value）的有序集合。一个数组以“[”（左中括号）开始，“]”（右中括号）结束。值之间使用“,”（逗号）分隔。

   

4. JSON数据类型

    一、4种基本类型 
        字符串(Strings)     如:"a"

        数字(numbers)      如:1，1.02

        布尔型(booleans)   true  false

        Null值(null)        　null

    二、两种结构类型
        对象  {"name":"zhangsan","age":18}    键为String ，值为Json的任意数据类型之一。对象的键值对是无序的。
        数组        [1,2,3]                顺序排列的零个或多个Json数据类型

三、关于使用c3p0：

•    如何使用c3p0+spring连接oracle数据库

  1. 首先是jdbc.properties属性文件的编写，便于数据库移植：

• datasource.driverClassName=oracle.jdbc.driver.OracleDriver
  datasource.url=jdbc:oracle:thin:@10.6.1.11:1521:student
  datasource.username=zs
  datasource.password=zs
  datasource.defaultAutoCommit=true 
  hibernate.dialect=org.hibernate.dialect.Oracle9Dialect
  
  #当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3
  c3p0.acquireIncrement=5
  #初始化时获取三个连接，取值应在minPoolSize与maxPoolSize之间。Default: 3 
  c3p0.initialPoolSize=10
  #每60秒检查所有连接池中的空闲连接。Default: 0 
  c3p0.idleConnectionTestPeriod=600
  #-连接池中保留的最小连接数。
  c3p0.minPoolSize=5
  #连接池中保留的最大连接数。Default: 15 
  c3p0.maxPoolSize=50
  #JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements
  #属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。
  #如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 0
  c3p0.maxStatements=100
  #c3p0是异步操作的，缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能
  #通过多线程实现多个操作同时被执行。Default: 3
  c3p0.numHelperThreads=10
  #最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 
  c3p0.maxIdleTime=600
  
  #hibernate.dialect=org.hibernate.dialect.SQLServerDialect
  hibernate.jdbc.batch_size=25
  hibernate.jdbc.fetch_size=50
  hibernate.show_sql=true
  hibernate.connection.release_mode=after_transaction

        2. 其次是spring配置文件的数据源配置：

• <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
   <property name="location">
    <value>/WEB-INF/classes/conf/jdbc/jdbc.properties</value>
   </property>
  </bean>
  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close" dependency-check="none">
   <property name="driverClass">
    <value>${datasource.driverClassName}</value>
   </property>
   <property name="jdbcUrl">
    <value>${datasource.url}</value>
   </property>
   <property name="user">
    <value>${datasource.username}</value>
   </property>
   <property name="password">
    <value>${datasource.password}</value>
   </property>
   <!-- 当连接池中连接耗尽的时候c3p0一次同时获取的连接数 -->
   <property name="acquireIncrement">
    <value>${c3p0.acquireIncrement}</value>
   </property>
   <!--初始化时获取三个连接，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->   
   <property name="initialPoolSize">
    <value>${c3p0.initialPoolSize}</value>
   </property>
   <!-- 最小连接数 -->
   <property name="minPoolSize">
    <value>${c3p0.minPoolSize}</value>
   </property>
   <!-- 最大连接数 -->
   <property name="maxPoolSize">
    <value>${c3p0.minPoolSize}</value>
   </property>
   <!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->    
   <property name="maxIdleTime">
    <value>${c3p0.maxPoolSize}</value>
   </property>
   <!--每60秒检查所有连接池中的空闲连接。Default: 0 -->
   <property name="idleConnectionTestPeriod">
    <value>${c3p0.idleConnectionTestPeriod}</value>
   </property>
   <!--JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements属于单个connection而不是整个连接池。
   所以设置这个参数需要考虑到多方面的因素。如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 0-->
   <property name="maxStatements">
    <value>${c3p0.maxStatements}</value>
   </property>
   <!--c3p0是异步操作的，缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能通过多线程实现多个操作同时被执行。Default: 3-->    
   <property name="numHelperThreads">
    <value>${c3p0.numHelperThreads}</value>
   </property>
  </bean>

        3. 最重要的是连接oracle数据库的驱动jar和c3p0的jar包

            c3p0-0.9.1.jar  这是c3p0的jar包

            classes12.jar(1.51MB) 连接oracle数据库的驱动，这个驱动十分重要。