1）ArrayList底层数组结构，原理：数组复制
2）底层自动扩容数组，初始为10，每次扩容上次的1/2
3）善于查询
4）利用index按顺序存储
LinkedList
1）底层链表结构（双链表）
2）善于插入删除数据
3）特殊方法：addLast（），addFirst（），removeFirst（），remove（）删除第一个；removeLast（）
总结：ArrayList更适合读取数据，linkedList更多的时候添加或删除数据。
重写：不同类中，方法体结构相同，逻辑代码可以不同，方法被定义为final不能被重写。
重载：同一类中，方法体结构相同参数列表类型和个数不能相同。
&和&&都可以作逻辑与，&它的左边无论是true还是false，右边的条件都要进行判断，&&它的左边如果是false，右边则不用进行判断。
&可以用作位运算符，将左边和右边两个数转换成二进制数然后进行与运算。
抽象类特点：
1）不能被实例化（子类继承后可实例化子类）
2）充当父类
3）有属性，方法，构造方法，抽象方法
4）抽象类中抽象方法必须被重写
5）子类有且只有一个父类
接口特点：
1）不能被实例化
2）充当父接口
3）有属性，抽象方法（属性必须初始化，且不能更改）
4）子类可以实现多个接口
6.接口可以继承接口，甚至可以继承多个接口；类可以实现多个接口，只能继承一个类。
5:写出JDBC操作数据库的步骤1：加载驱动Class.forName("com.mysql.jdbc.Driver");2：创建连接Connectioncon=DriverManager.getConnection("url","1111","1111");3：创建语句PreparedStatementps=con.prepareStatement("select*fromuser");4：执行语句ResultSetrs=ps.executeQuery();5：处理结果while(rs.next()){rs.get.....（“”）；}6：关闭资源finally{if(con!=null){try{con.close();}catch(SQLExceptione){e.printStackTrace();}}}
加载驱动-创建连接-创建语句-执行语句-处理结果-关闭资源
1.HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口2.主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高Hashtable3.HashMap允许将null作为一个entry的key或者value，而Hashtable不允许4.最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是
HashMap线程不安全。HashMap是map接口的子接口，是将键映射到值的对象，其中键和值都是对象，并且不能包含重复键，但可以包含重复值。HashMap允许包含空键和空值，而HashTable不允许空键值。
HashTable线程安全。HashMap是HashTable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空键值，由于非线程安全，所以效率上可能高于HashTable。
方式：继承Thread、实现Runnable接口产生:-一个资源每次只能被一个进程使用-一个进程因请求发生阻塞时，依然对已获得的资源保持不放-进程已经获得资源使用权，但是一直未使用-同一个进程，频繁的获取资源的优先使用权，一直未释放防止：加锁顺序（线程按照一定的顺序加锁）加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该
锁的请求，并释放自己占有的锁）死锁检测（一般是将所有的锁存放于map对象中，检测map中的锁）
1.运行速度快慢为：StringBuilder>StringBuffer>String-（String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的）2.StringBuilder是线程不安全的，而String、StringBuffer是线程安全的
TCP稳定性较高，但效率低。TCP三次握手协议。UDP通讯相反，效率较高，但稳定性较差
三个编译指令为：page、include、taglib七个动作指令为：jsp:forward、jsp:param、jsp:include、jsp:plugin、
jsp:useBean、jsp:setProperty、jsp:getProperty
1：Setter方法2：构造器3：接口注入注解实现注入(常用)
1.mybatis为我们提供了两种支持动态sql的语法：#{}以及${}2.#方式能够很大程度防止sql注入，$方式无法防止Sql注入3.$方式一般用于传入数据库对象，例如传入表名4.＃{}将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号5.一般能用#的就别用$
Cookie和session做状态管理
的性能单个cookie在客户端的限制是3K，就是说一个站点在客户端存放的COOKIE
不能大于3K
GET：1：从服务器上获取数据，一般不能使用在写操作接口2：由URL所限制，GET方式传输的数据大小有所限制，传送的数据量不超过2KB3：请求的数据会附加在URL之后，以？分隔URL和传输数据，多个参数用&连接4：安全性差POST:1：向服务器提交数据,一般处理写业务2：POST方式传送的数据量比较大，一般被默认为没有限制3：安全性高4：请的求的数据内容放置在HTMLHEADER中
1：效率上转发（forward）>重定向（redirect）2：显示上重定向（redirect）：显示新的URL转发（forward）：地址栏不变3：数据上转发（forward）：可以共享request里面的数据重定向（redirect）：不能4：请求次数重定向（redirect）是两次转发（forward）是一次
1：hibernate的扩展性和移植性比mybatis强2：hibernate不需要写sql语句，会自动生成，而mybatis则需要写sql
语句3：hibernate支持事务、一级缓存、二级缓存、查询缓存等4：hibernate自己提供分页功能，mybatis需要配置分页插件
组件：strutsParperAndExecuteFilterActionResultInterceptor标签：packageactionresultparaminterceptor返回值类型：dispatcherredirectredirectActionstreamjson
2<<3
@Autowired--自动装配@Component--自动支持自动装配@Repository--DAO层实现@Service--Service层实现@Controller--Web层实现
F5：进入方法内F6：执行下一步F7：跳出方法外F8：执行到下一个断点
端口：server.xml项目缓存：删除work文件夹下的文件并发：150-200
两个字节，可以存储，前提是汉字必须是Unicode编码
等等实现AOP功能关键是采用代理技术，主要分为静态代理(AspectJ)和动态代
理，JDK中采用Proxy类产生动态代理的方式为某个接口生成实现类，如果要
为某个类生成子类，则可以用CGLIB。
1：Struts2-导包-加载struts.xml-配置web.xml-filter2：Struts2+Spring-导中间包、Spring包-增加Spring的配置文件Applicationcontext.xml-配置web.xml-context和监听3：Hibernate-导包-增加hibernate的配置文件hibernate.hbm.cfg和表的映射文件-配置数据库的方言和连接、加载映射文件4：Hibernate+Spring-导中间包-在spring的配置文件中加载hibernate的配置信息
1:Spring-导包-增加Spring的配置文件Applicationcontext.xml-配置web.xml2：springMVC-导包-增加springMVC的配置文件context-dispatcher.xml-配置web.xml3：mybatis-导包-增加mybatis的配置文件mybatis-config.xml-将mybatis的配置文件在spring和springMVC中进行引用和配置
Thread的start才是正在开启线程;Run只是调用了一个普通方法，并没有启动另一个线程，程序还是会按照顺序执行相应的代码。Start则表示，重新开启一个线程，不必等待其他线程运行完，只要得到cup就可以运行该线程。
静态变量前面要加static，实例变量不用。实例变量属于对象的属性，必须创建了实例对象，才可以被使用，静态变量不属于某个实例对象，而是属于类，也叫类变量，不用创建任何实例对象就会被使用。
json、file、xml、jsonp等
字节流：按字节读写字符流：按字符通常在处理文本时优先使用字符流，其他的用字节流
字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符
流在操作时使用了缓冲区，通过缓冲区再操作文件
string、list、set、zset、hash
1.导包2.Jedisjd=newJedis(IP);3.jd.ping();//PONG
key-value---Redis文档存储-----MongoDB
文档(document)、集合(collection)、数据库(database)
Redis：数据量较小的更性能操作和运算上
MongoDB:主要解决海量数据的访问效率问题
导包
//建立连接MongoClientmc=newMongoClient("192.168.168.220",27017);MongoDatabasedb=mc.getDatabase("db1");//数据库名称
altertable表名add字段类型NOTNULLDefault0;
==：比较两个数据内存地址是否相同
equals：比较两个数据值是否一样
++i:先赋值，后运算
i++：先运算，后赋值
list：-链表-有序-继承Collection(set也是)-可以有重复的对象值，但是对象下标不能重复Map：-key-value-无序-键不能有重复的值可以用
int是基本数据类型，初值为0。Integer是int的包装类，初值为nullInteger缓存：注意拆箱和装箱（-128-127之间）原始类型：boolean，char，byte，short，int，long，float，double包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double
oracle：rownum关键词、row_number()函数mysql：limit0,5/limit5;
务逻辑处理。如：jsp、html等模型：表示业务数据和业务处理。属于数据模型，如:entity、jdbc、
hibernate、mybatis等控制器：接收、响应用户请求，servlet、action、controller等
不一定相同；一定
通过调用init()方法进行初始化；调用service()方法来处理客户端的请求；通过调用destroy()方法终止（结束）Servlet是由JVM的垃圾回收器进行垃圾回收的；
-进程是资源的分配和调度的一个独立单元，而线程是CPU调度的基本单元-同一个进程中可以包括多个线程-进程结束后它拥有的所有线程都将销毁，而线程的结束不会影响同个进程中的其他线程的结束-线程共享整个进程的资源（寄存器、堆栈、上下文），一个进行至少包括一个线程-进程的创建调用fork或者vfork，而线程的创建调用pthread_create-线程中执行时一般都要进行同步和互斥，因为他们共享同一进程的所有资源
JDK是Java的开发工具，JDK包含JRE。JRE只是Java程序的运行环境，它最核心的内容就是JVM（Java虚拟机）
及核心类库。
处理请求的Controller3.DispatcherServlet将请求提交到Controller4.Controller调用业务逻辑处理后，返回ModelAndView5.DispatcherServlet查询一个或多个ViewResoler视图解析器，找到
ModelAndView指定的视图6.视图负责将结果显示到客户端DispatcherServlet是整个SpringMVC的核心。它负责接收HTTP请求
组织协调SpringMVC的各个组成部分
1**：信息性状态码2**：成功状态码200：请求正常成功204：指示请求成功但没有返回新信息206：指示服务器已完成对资源的部分GET请求3**：重定向状态码301：永久性重定向302：临时性重定向304：服务器端允许请求访问资源，但未满足条件4**：客户端错误状态码400：请求报文中存在语法错误401：发送的请求需要有通过HTTP认证的认证信息403：对请求资源的访问被服务器拒绝了404：服务器上无法找到请求的资源5**：服务器错误状态码500：服务器端在执行请求时发生了错误503：服务器暂时处于超负载或正在进行停机维护，现在无法处理请求
对象关系映射（ObjectRelationalMapping，简称ORM）为了解决面向对象与关系数据库存在的互不匹配的现象的技术，ORM是通过使用描述对象和数据库之间映射的元数据(元数据一般采用XML格式)，将程序中的对象自动持久化到关系数据库中，Java典型的ORM中间件有:Hibernate,ibatis,speedframework,mybatis
(InversionofControl,简称IOC)，即控制反转，是一种设计模式，是spring的核心。可以解决代码耦合，由IOC容器来管理对象的生命周期、依赖关系等。
page：当前页面有效request：一次会话请求有效session：浏览器进程，只要浏览器不关闭，则一直有效application：服务器只要运行，则有效
1：修饰类：表示该类不能被继承2：修饰方法：表示方法不能被重写3：修饰变量：表示变量只能一次赋值以后值不能被修改（常量）
1:Error表示系统级的错误和程序不必处理的异常,有可能恢复，但是恢复比较困难的严重问题。2：Exception表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；也就是说，它表示如果程序运行正常，从不会发生的情况异常处理的原则：1：System.out.println是高代价的。调用System.out.println会降低系统吞吐量2：在生产环境中别用异常的printStackTrace()方法。3：如果你不能处理异常，不要捕获该异常4：如果要捕获，应在离异常源近的地方捕获它5：捕获的异常一定要做处理6：可以自定义异常7：就近原则
1：开启所有服务器的二进制文件2：开启所有从服务的IO和SQL线程3：配置主从连接的用户信息和主从信息4：开启3306端口号
NIO:是一种newIO，其目的是为了实现高速IO的代码，将IO操作并转换为操作系统，属于非阻塞型，java.nio.*，是以块（缓冲区）的形式就行数据的传输。IO：是以流的方式就行数据的传输，属于阻塞型，影响程序的性能传统阻塞IO，如果你要read/write(byte[10M])一个10M的文件，一旦调用了read/write(byte[10M])这个方法，就得等10M全部read/write，方法底层才会返回。非阻塞线程，调用read/write(byte[10M])方法立即返回，当然这并不能代表10M已经read/write完成，你需要检测这个byte[10M]的缓冲区。
单例模式（Singleton），也叫单子模式，是一种常用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。单例模式只允许创建一个对象，因此节省内存，加快对象访问速度单例模式要素：a.私有构造方法b.私有静态引用指向自己实例c.以自己实例为返回值的公有静态方法饿汉式：单例实例在类装载时就构建，急切初始化。（预先加载法）优点1.线程安全2.在类加载的同时已经创建好一个静态对象，调用时反应速度快缺点资源效率不高，可能getInstance()永远不会执行到，但执行该类的其他静态方法或者加载了该类（class.forName)，那么这个实例仍然初始化懒汉式：单例实例在第一次被使用时构建，延迟初始化。应用场景：-需要频繁实例化然后销毁的对象-创建对象时耗时过多或者耗资源过多，但又经常用到的对象-有状态的工具类对象-频繁访问数据库或文件的对象-网站计数器，一般是采用单例模式实现-由于配置文件一般都是共享资源，即web应用的配置对象的读取，一般采用单例模式来实现。如：spring的配置文件的读取等-多线程的线程池的设计一般也是采用单例模式-数据库连接池的设计
public、final、abstract
8种基本数据类型：byte8位取值范围-2^7~2^7-1short16位取值范围-2^15~2^15-1char16位取值范围0~2^16-1boolean位数不明确取值范围truefalseint32位取值范围-2^31~2^31-1long64位取值范围-2^63~2^63-1float32位取值范围1.4e-45~3.40e38double64位取值范围4.9e-324~1.79e308注意：需要注意的是，String不是基本数据类型，而是引用类型在jdk1.5中引入了自动拆装箱的新特性，自动拆装箱，是指基本数据类型和引用数据类型之间的自动转换基本类型转换成包装类型，称为装箱IntegerintObjct=newInteger(2);//装箱//IntegerintObjct=2//自动装箱//自动装箱，如果一个基本类型值出现在需要对象的环境中，会自动装箱如Integer和int可以自动转换；Float和float可以自动转换
round方法，他表示“四舍五入”，算法为Math.floor(x+0.5),即将原来的数字加上0.5后再向下取整12、-11
饿汉式单例：publicclassSingleton{privateSingleton(){}privatestaticSingletoninstance=newSingleton();publicstaticSingletongetInstance(){returninstance;}}懒汉式单例：publicclassSingleton{privatestaticSingletoninstance=null;privateSingleton(){}publicstaticsynchronizedSingletongetInstance(){if(instance==null)instance＝newSingleton();returninstance;}}
构造器不能被继承，因此不能重写Override，但可以被重载Overload
-jsp本质就是servlet-jsp应用于页面显示，servlet应用于逻辑控制-setvlet中没有内置对象，jsp中的内置对象都是必须通过HttpServletRequest对象，HttpServletResponse对象及HttpServlet对象得到
-Lock能完成几乎所有synchronized的功能，并有一些后者不具备的功能，如锁投票、定时锁等候、可中断锁等候等-synchronized是Java内置的关键字，Lock则是JDK5中出现的一个包-synchronized同步的代码块可以由JVM自动释放；Lock需要程序员在finally块中手工释放
xml-dom4jexcel-poi、jxl
发布JAR包、发布WAR包、部署到自动化容器中
概念：序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化（将对象转换成二进制）。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题序列化：把Java对象转换为字节序列的过程。反序列化：把字节序列恢复为Java对象的过程。实现：将需要被序列化的类实现Serializable接口注意：被关键字static、transient修饰的变量不能被序列化。在被序列化后，transient修饰的变量会被设为初始值。如int型的是0、对象型的是null.
用break;return方法。
-抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。-继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。-封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。-多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
Collection是集合类的上级接口继承与他的接口主要有Set和List.Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
GC是垃圾收集的意思（GabageCollection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法
wait():使一个线程处于等待状态，并且释放所持有的对象的lock。sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
<%@pageisThreadSafe=”false”%>
request，session，application，cookie等
Java中的23种设计模式：Factory（工厂模式），Builder（建造模式），FactoryMethod（工厂方法模式），Prototype（原始模型模式），Singleton（单例模式），Facade（门面模式），Adapter（适配器模式），Bridge（桥梁模式），Composite（合成模式），Decorator（装饰模式），Flyweight（享元模式），Proxy（代理模式），Command（命令模式），Interpreter（解释器模式），Visitor（访问者模式），Iterator（迭代子模式），Mediator（调停者模式），Memento（备忘录模式），Observer（观察者模式），State（状态模式），Strategy（策略模式），TemplateMethod（模板方法模式），ChainOfResponsibleity（责任链模式）工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。
List以特定次序来持有元素，可有重复元素。Set无法拥有重复元素,内部排序。Map保存key-value值，value可多值。
1：数据库设计数据库表：字段类型、字段长度、注释、字段命名规范数据库索引：外键、关联字段、查询频率比较高的字段、如果数据表字段>20，则最多支持16个索引如果数据表字段<20，则根据查询频率字段来定数据库视图：相当于一张临时表，业务中，尽量少使用数据库引擎：根据业务，选择对应的表引擎技术数据库存储过程：尽量少用数据库字符：UTF-8、或者和页面字符保持一致数据库监听器/触发器：一般用于调度任务或者备份还原2：业务调用的sql语句优化xml：尽量少关联表，效率最高关联4张表，如果多于4张表，则需要开启两个链接事务，但是这两个事务，必须在一个service当中。如果是查询语句，则不建议使用*如果是查询语句，where条件后面，最好使用索引字段进行关联3：数据库服务器的搭建（集群）主从配置：读写分离：自动化（容器）：
回车
1、一级缓存是session独享，默认开启，无需配置
2、二级缓存是session共享，需要在配置文件中开启，可以指定缓存区域块
HQL语句查询、Criteria查询、NativeSQL查询
A、java的数组可以随时改变大小
B、String字符串的长度和大小都是不可变的
C、boolean类型变量默认初始值为true（false）
D、Java虚拟机是实现跨平台的基础
publicstaticvoidmain(String[]args){
intx=1,y=1,z=1;
if(x--==1&&y++==1||z++==1){
System.out.println(“x=”+x+”,y=”+y+”,z=”+z;);
}
A:x=0,y=2,z=1B:x=1,y=2,z=1
C:没有输出D:x=0,y=2,z=2
A.publicstaticvoidmain(String[]args){
byteb1=1;
byteb2=2;
byteb=b1+b2;
B.publicstaticvoidmain(String[]args){
intn=100;
while(n>0){
System.out.println(n);
C.publicstaticvoidmain(String[]args){
intn;
for(inti=0;i<10;i++){
n+=i;
D.publicstaticvoidmain(String[]args){
for(;;){
publicclassTest{
int[]a={1,2,3,4,5};
int[]b=change(a);
b[1]=7;
System.out.println(a[1]);
publicstaticint[]change(int[]a){
a[1]=6;
returna;
A、编译错误B、运行出错C、6D、7
A、构造函数是类的特殊函数，他的方法名必须与类名相同
B、构造函数没有返回值类型
C、一个类可以有多个构造函数
D、构造函数在类加载时调用
classParent{
inti=2;
publicParent(){
System.out.println("parent");
classChildextendsParent{
inti=5;
publicChild(){
System.out.println("child");
Parentp=newChild();
System.out.println(p.i);
运行编译后，输出结果为()
A.child2B.child5C.parentchild2D.parentchild5
classClassA{
intvalue;
publicclassTestClassA{
intvalue=10;
changeInt(value);
System.out.println(value);
ClassAca=newClassA();
ca.value=10;
changeObject(ca);
System.out.println(ca.value);
publicstaticvoidchangeInt(intvalue){
++value;
publicstaticvoidchangeObject(ClassAca){
ca.value++;
A.编译不通过B.10,11C.10,10D.11,11
publicclassTest1{
List
list.add("aa");
list.add("java");
list.add("bb");
A、for(inti=0;i if("java".equals(list.get(i))){ list.remove(i); B、for(inti=list.size()-1;i>=0;i--){ C、list.remove(“java”); D、list.removeAll(“java”); publicstaticStringoutPut=""; publicstaticvoidfoo(inti){ try{ if(i==1) thrownewException(); outPut+="1"; }catch(Exceptione){ outPut+="2"; return; }finally{ outPut+="3"; outPut+="4"; foo(0); System.out.println(outPut); foo(1); A、13413423B、1134C、13434D、134134134 classT1{ inti=0; publicvoidTest1(){ System.out.println(i); publicvoidTest2(){ classT2extendsT1{ publicclassTestCase{ T1test=newT2(); test.Test1(); test.Test2(); System.out.println(test.i); test=(T2)test; A、0000B、0200C、0222D、编译不能通过 拦截器和过滤器的区别： 1、过滤器是依赖于Servlet容器，拦截器不依赖于容器 2、过滤器是可以拦截所有请求，拦截器只针对Action起作用 3、过滤器只在容器初始化执行一次，拦截器可以多次执行 4、过滤器不能访问值栈中的对象，拦截器可以访问值栈中的对象 5、过滤器底层实现：回调 拦截器底层实现：反射 cookie和Session 状态管理: web应用程序是基于HTTP协议的，而HTTP协议是无状态的协议，无状态也就是说一次请求，一次响应之后即断开连接，而同一个用户的下一次请求需要重新建立连接，但在有时候服务器需要判断是否为同一个用户的多次操作，所以这些时候需要将用户的多次请求当做说一个整体来看待，并且将多次交互涉及到的数据进行保存下来 状态：交互产生的数据 管理：多次交互对数据的修改 实现状态常见的有两种方式 cookie：浏览器客户端状态管理，将状态保存在浏览器客户端 session：服务器状态(数据)管理，将状态保存在服务器 Cookie：实现原理 1、浏览器客户端第一次访问服务器端返回响应数据时，响应数据包中以Set-Cookie消息头方式给浏览器返回cookie信息 Set-Cookie：name=张三 Set-Cookie：count=10； 2、浏览器接受服务器端的响应数据包之后，解析响应数据包，获取cookie信息，保存在客户端 3、客户端在后续每一次访问时，需要携带保存cookie，以cookie请求消息头方式发给服务器 cookie：name=张三，count=10 4、服务器接受请求之后，获取请求数据包中cookie信息进行操作，完成HTTP状态管理 Session 2、在服务器第一次给客户端返回响应时，把JESSIONID以Set-Cookie消息头方式带回给浏览器客户端 Set-Cookie：JESSIONID=xxxx 3、在客户端接受到响应数据包之后，解析出JESSIONID以cookie形式存储在浏览器客户端 4、在后续浏览器客户端每一次发送请求时，以Cookie消息头方式把JESSIONID发送给服务器 Cookie：JESSIONID=xxxx 5、服务器获取JESSIONID后，根据JESSION去找相应的session对象，完成状态管理 IOC：InversionofControl控制反转 改变对象的创建方式，由最初的new方式创建对象，转变为由spring容器去创建和管理。降低对象之间的耦合度；IOC是整个spring框架的核心，spring其他所有功能都是基于IOC基础之上完成的。 DI：DenpencyInjection依赖注入 1、DI作用是维护对象之间的关系，将一起工作具有关系的对象通过构造器或者set方法传入值建立关系。 2、IOC是一种思想，DI是实现IOC思想的途径 AOP：AspectOrientedProgramming面向切面编程 将一个系统中公用的业务逻辑进行提取出来，单独封装成一个组件(切面)，然后再以配置的方式作用到系统中，实现程序的可插拔性，提高代码复用，提升系统性能。 AOP底层实现原理 动态代理模式：可以根据一个类去动态的生成另外一个类，代理类会拥有委托类的API方法。 Hibernate对象有三种状态，分为： 1、临时态：内存中有对象，数据库没有与之对应的数据，新建的对象也是临时状态，持久状态的对象调用了delete()方法也会变成新建状态； 2、持久态：内存中有对象，数据库有与之对应的数据，修改对象的属性，数据库中数据也会跟着修改。持久状态的对象存在于内存的session缓存区域。 2.1>新建状态调用了save()或者saveOrUpdate()会变成持久状态 2.2>通过id从数据库get()或者load()出来的对象也是持久态的对象 2.3>游离态对象调用了save()或者saveOrUpdate()方法也会变成持久态 3、游离态 内存中有对象，数据库中有之对应的数据，但是对象处于离线状态，修改对象的属性，数据库数据不会修改 事务的特性： 1、原子性（Atomicity）2、一致性（Consistency）3、隔离性（Isolation）4、持久性（Durability） 事务的隔离级别：事务的隔离级别也分为四种，由低到高依次分别为：readuncommited（读未提交）、readcommited（读提交）、readrepeatable（读重复）、serializable（序列化），这四个级别可以逐个解决脏读、不可重复读、幻读这几类问题。 1.readuncommited：是最低的事务隔离级别，它允许另外一个事务可以看到这个事务未提交的数据。 2.readcommited：保证一个事物提交后才能被另外一个事务读取。另外一个事务不能读取该事物未提交的数据。 3.repeatableread：这种事务隔离级别可以防止脏读，不可重复读。但是可能会出现幻象读。它除了保证一个事务不能被另外一个事务读取未提交的数据之外还避免了以下情况产生（不可重复读）。 4.serializable：这是花费最高代价但最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读之外，还避免了幻象读。 脏读：指当一个事务正字访问数据，并且对数据进行了修改，而这种数据还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。因为这个数据还没有提交那么另外一个事务读取到的这个数据我们称之为脏数据。依据脏数据所做的操作是不正确的。 幻读：一个事务先后读取一个范围的记录，但两次读取的纪录数不同，我们称之为幻象读（两次执行同一条select语句会出现不同的结果，第二次读会增加一数据行，并没有说这两次执行是在同一个事务中） 不可重复读：指在一个事务内，多次读同一数据。在这个事务还没有执行结束，另外一个事务也访问该同一数据，那么在第一个事务中的两次读取数据之间，由于第二个事务的修改第一个事务两次读到的数据可能是不一样的，这样就发生了在一个事物内两次连续读到的数据是不一样的，这种情况被称为是不可重复读 Spring事务传播特性： 事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持支持7种事务传播行为： propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个，加入到这个事务中，这是最常见的选择 propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。 propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。把当前事务挂起。 propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作类似的操作 Spring默认的事务传播行为是默认的事务传播行为是PROPAGATION_REQUIRED，它适合于绝大多数的情，它适合于绝大多数的情况。假设ServiveX#methodX()都工作在事务环境下（即都被Spring事务增强了），假设程序中存在如下的调用链：Service1#method1()->Service2#method2()>Service3#method3()，那么这，那么这3个服务类的3个方法通过Spring的事务传播机制都工作在同一个事务中 1.建立适当的索引 2.避免在索引上使用计算 3.避免在索引列上使用NOT 4.避免在索引上使用ISNULL和ISNOTNULL 5.避免不必要的行和列 6．Select子句中避免使用* 7.在IN后面值的列表中，将出现最频繁的值放在最前面，出现最少的放在最后，减少判断次数。 8.使用batch处理 9.注意Union和Unionall的区别 10.Where子句中的连接顺序 11.DISTINCT的使用：注意，在数据量大的时候，尽量不要使用，它同UNION一样会使查询变慢。因为Oracle需要对后面的所有字段进行排序，消耗性能。 将6升水倒入5升的，6升剩下1升；把1升水放入到5升壶中，再用6升壶水倒入放有1升水的5升壶，6升壶剩余2升；把这2升水在倒入5升壶，再用6升壶倒入5升壶，6升的壶就剩余3升水； SSH、SSM框架测试题 --将答案写在答题纸上 struts2执行流程(重点） 1、浏览器向服务器发起请求 2、请求首先会被提交到web.xml中定义的前端过滤器filter中 3、前端过滤器解析请求路径，在根据struts.xml文件中的配置，决定将这个请求交给哪一个action进行处理，并且指定交由哪一个业务方法进行处理 4、业务方法处理完请求之后，会给前端过滤器返回一个字符串 5、前端过滤器拿到字符串之后在根据struts.xml中result配置找到相应的页面然后在进行返回 1、值栈是什么 --当前action对象 --action中定义的属性(有set／get方法) --action中定义的域对象：request，session，application 2、值栈的作用 Action向页面传输值的缓存区 3、值栈到存值区域 root区（list区域）：以栈结构形式存储当前Action中的属性以及直接往栈中push的元素 request，session，application 4、OGNL Struts2中定义的一种表达式语言，主要用于可以从值栈中取值 4.1、引入Struts2的标签库 4.2、从root区域取值 靠近栈顶到同名会被先取出来，然后就不再往下查询 4.3、从context区域取值 1、在Action中通过ServletActionContext获取到request对象，然后调用request.getParameter("key值") 2、属性注入 2.1、请求参数key值（一般是表单name值），必须和action中定义的属性名保持一致 2.2、action中属性提供set/get方法。 3、域模型传值 针对表单中请求参数较多 3.1、创建一个实体类，根据表单中提交项定义属性，属性要提供set/get方法 3.2、在action中定义一个实体类对象属性，属性提供set/get方法 3.3、表单中的提交项name属性中为action实体对象名.实体类属性名 如：name="user.username" name="user.password" Struts2中定义的对Action进行动态拦截的对象，拦截器中的方法会在Action调用前后都会执行，也可以通过动态设置来阻止Action执行。 拦截器的作用：封装代码通用逻辑，以便于重复利用，如：登陆验证，日志记录，权限控制；而且拦截器可以通过动态配置来使用，提供系统灵活性，实现解耦合。 IOC：InversionofControl控制反转；改变对象的创建方式，由最初的new方式创建对象，转变为由spring容器去创建和管理，降低对象之间的耦合度。IOC是整个spring框架的核心，spring其他功能都是基于IOC基础上完成的。 DI:DenpencyInjection依赖注入，DI的作用是维护对象之间的关系，将一起工作具有关系的对象通过构造器或者set方法传入值建立关系。 IOC是一种思想，DI是实现IOC思想的途径 AspectOrientedProgramming面向切面编程 将一个系统中公用的业务逻辑进行提取出来，单独封装成一个组件(切面)， 然后再以配置的方式作用到系统中，实现程序的可插拔性，提高代码复用， 提升系统性能。 二、AOP底层实现原理 动态代理模式：可以根据一个类去动态的生成另外一个类，代理类会拥有 委托类的API方法。 JDK动态代理(只支持接口注入) CGLIB动态代理(可以支持普通类注入) 三、AOP和OOP区别 1、AOP是以OOP为基础 2、OOP侧重于对象的封装，AOP侧重于共通业务逻辑的封装 四、AOP使用方式 1、切面：Aspect 系统中共通业务逻辑的封装，会在某个时刻或者阶段共通调用，强调 调用时机相同，如：事务处理，异常处理，日志，安全验证，权限验证 2、切入点：PointCut 切入点目标：给谁追加共通处理 在spring中提供切入点表达式(正则表达式) 1>名称限定表达式(切入到方法) 语法：execution(修饰符？返回值类型|*方法名|*(参数列表|..)) 2>类型限定表达式(切入到某一个类) 语法：within(类型) 3、通知advice 什么时候调用共通的业务逻辑 主要用于指定切面作用到切入点上的时机 在spring中提供了五种类型通知 1>前置通知-->目标方法调用前@Before 2>后置通知-->目标方法调用后@AfterReturning 3>异常通知-->目标方法产生异常后调用@AfterThrowing 4>最终通知-->目标方法进行finally调用@After 5>环绕通知-->目标方法调用前后都会执行@Around 环绕通知=前置通知+后置通知 在Spring框架中，所有的Java类和JavaBean对象都会被当作是一个bean组件，这些bean组件都是由spring容器负责管理和创建以及维护这些对象之间的关系。 1、管理对象的实例化(最常用) 构造器构建对象 静态工厂构建对象 实例工厂构建对象 2、管理对象的作用域 scope="singleton"默认，单例模式，每次调用getBean()返回同一个对象 scope=“prototype”每次调用getBean()返回一个新的对象 3、管理对象的生命周期 init-method=“”bean组件的初始化方法， 在bean组件实例化完成后自动调用， destroy-method=""bean组件销毁方法，单例bean组件在容器关闭时调用 4、延迟实例化对象 在spring容器中所有的单例bean默认在容器启动时构建对象 lazy-init=“true”将单例对象实例化时机延迟到调用getBean()方法时调用 lazy-init="false"默认值，容器启动构建单例对象 1、Restful 表现层状态转移，是一个软件设计风格，主要是用于对网络上的资源进行统一定位以及规定统一操作的方式 2、网络上的资源(核心) 1>网络上的所有数据都可以抽象为资源，Restful可以对资源进行标识 2>无论以任何方式来操作这个资源都不会影响资源标识 3、Restful优点 1>降低程序复杂性 2>提高程序的可伸缩性 4、SpringMVC对Restful的支持 1>统一规定网络上资源的标识 2>统一规定访问资源的方式 5、如何编写Restful风格的SpringMVC应用 1>将前端过滤器中请求路径url-pattern改为/ DispatcherServlet当拦截到请求之后，会将请求拿到映射器中做匹配，匹配上了进入处理器，匹配不上之间返回404，不会去找静态页面 解决问题：将*.do改为/之后，webContent目录下HTML/css/js/image等等静态资源无法访问 2>导入SpringMVC对Ajax的支持包，借助Ajax客户端向服务器发送DELETE，PUT请求 3>在Controller中通过@RequestMapping注解，添加要处理的请求URL模板和Http请求的动作类型 4>利用@PathVariable注解将URL上的变量映射到处理方法的参数上 1、#先编译，然后在传值，传的值都是字符串;$直接拼接字符串 2、$会造成SQL注入，#不会 3、传入表名和列名可以用$ 4、传入值的时候必须使用#，不要使用$ @AutoWired:spring框架自带注解 先按照类型进行匹配，如果存在多个匹配的类型会报错 @Resource：JavaEE中注解 推荐使用，解耦合；按照名称进行注入，查看spring容器中是否有bean对象的id值和引用名一样， 如果按照名称查找不到bean组件，就按照类型注入。 如果在容器中有多个匹配，可以强制按照名称注入。 @Autowired @Qualifier("匹配的id值")或者@Resource(name="id值")； 延迟加载：lazyload懒加载 在尽可能晚的情况下，真正需要使用到数据的时候，才会向数据库发送sql语句执行查询，加载 数据到内存中，避免了无谓的性能开销。 load()延迟加载：不发送SQL语句，而默认返回一个代理对象，只保存对象的ID值。 get()取消延迟加载：发送SQL语句，但是只会查询当前对象的完整信息，如果当前对象还有关 联的集合数据或者对象，默认都是延迟加载，不会发送SQL语句去查询其关联的对象或集合。 Hibernate和Mybatis的二级缓存除了采用系统默认的缓存机制外，都可以通过实现你自己的缓存或为其他第三方缓存方案，创建适配器来完全覆盖缓存行为。 不同点：Hibernate的二级缓存配置在SessionFactory生成的配置文件中进行详细配置；MyBatis的二级缓存配置都是在每个具体的表-对象映射中进行详细配置，这样针对不同的表可以自定义不同的缓存机制。并且Mybatis可以在命名空间中共享相同的缓存配置和实例，通过Cache-ref来实现。 两者比较：因为Hibernate对查询对象有着良好的管理机制，用户无需关心SQL。所以在使用二级缓存时如果出现脏数据，系统会报出错误并提示。 而MyBatis在这一方面，使用二级缓存时需要特别小心。如果不能完全确定数据更新操作的波及范围，避免Cache的盲目使用。否则，脏数据的出现会给系统的正常运行带来很大的隐患。 Hibernate与MyBatis都可以是通过SessionFactoryBuider由XML配置文件生成SessionFactory，然后由SessionFactory生成Session，最后由Session来开启执行事务和SQL语句。 而MyBatis的优势是MyBatis可以进行更为细致的SQL优化，可以减少查询字段，并且容易掌握。 Hibernate的优势是DAO层开发比MyBatis简单，Mybatis需要维护SQL和结果映射。数据库移植性很好，MyBatis的数据库移植性不好，不同的数据库需要写不同SQL。有更好的二级缓存机制，可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。 Hibernate：创建关联映射，在映射文件中的加入维持关系的外键名称 Mybatis：创建关联映射，在映射文件中添加多方集合属性名 事物的传播特性： 1、原子性：指事物包含所有的操作要么完全成功，要么完全失败，事物的操作如果成功就必须要完全应用到数据库，如果失败就不能对数据库有任何的影响 2、一致性：指事物必须使数据库从一个一致性变换到另一个一致性，也就是说一个事物执行之前和执行之后都必须处于一个一致性状态。 3、隔离性：是当多个用户一起访问数据库时，操作同一个数据时，数据库为每一个用户开启事物，每个用户不被其他用户的事物影响干扰，多个并发事物之间要相互隔离。 4、持久性：指一个事物一旦被提交了，那么数据库的改变就是永久性的。即便是在系统遇到故障的情况下也不会丢失提交事物的操作。 隔离级别： 1、Serializable（串行化）：可避免脏读，不可重复读，幻读的发生。 2、Repeatableread(可重复读)：可避免脏读、不可重复读的发生。 3、Readcommitted(读已提交)：可避免脏读的发生。 4、Readuncommitted(读未提交)：最低级别，任何情况都无法保证。 最高级别的事Serializable级别，最低的是Readuncommitted级别。Mysql数据库中默认的隔离级别为Repeatableread（可重复读） 1、创建一个文件上传表单；表单提交方式为post，表单编码ectype=‘multipart/form-data' 限制文件上传大小 单个action： 整个项目设置： 1、临时态（瞬时态）：内存中有对象，数据库中没有与之对应的数据，新建的对象是临时状态，持久态的对象调用了delete()方法也会变成新建状态。 2、持久态：内存中有对象，数据库中有与之对应的数据，修改对象的属性，数据库中数据也会发生改变。持久状态的对象存在于内存的session缓存区域。 新建状态调用了sava()或者saveOrUpdate()会变成持久状态。 通过id从数据库get()或者load()出来的对象也是持久状态对象 游离态对象调用save()或者saveOrUpdate()方法也会变成持久状态 3、游离态：内存中有对象，数据库有之对应的数据，但是对象处于离线状态，修改对象数据库中数据不会修改。 Session关闭 清空session缓存 从session中剔除某个持久态对象 1、页面向服务器发起请求，页面被提交到前端控制器 2、前端控制器接受到请求后调用处理器映射器HandlerMapping，映射器根据请求路径和映射规则找到相应的处理器Handler 3、前端控制器会根据映射器找到相应的处理器类型调用对应的设配器，适配器在调用处理器的业务方法 4、处理器中业务方法处理请求流程，处理完成之后会返回一个ModelAndView对象给处理器适配器 5、处理器适配器再将ModelAndView对象返回给前端控制器 6、前端控制器拿到ModelAndView对象之后取出其中的视图名称，在调用试图解析器找到相应的页面 7、在取出ModelAndView对象之后取出其中的视图名称，在调用视图解析器找到相应的页面 8、将JSP响应页面返回给客户端 适配器映射器：根据请求路径以及映射规则找到对应的handler处理器 适配器：根据映射找到的处理器类型，调用不同的适配器，适配器去调用处理器中方法； 注解的映射器和适配器要配对使用 前端控制器取出ModelAndView对象中的视图名称，在根据试图解析器中配置找到相应的试图页面 1、自定义过滤器实现Filter接口，在相应的业务方法中对中文进行处理 2、使用spring框架自带的过滤器CharacterEncodingFilter 用于向请求发起端返回一个JSON类型的字符串 1、引入一个插件：struts2-json-plugin-2.1.8.jar 2、package的extends必须继承json-default 3、result类型 4、在Action中定义的只要提供了set/get方法都会以json格式进行返回 5、如果只想返回Action中部分数据，将需要返回的数据存入到map中 1、load()方法启用延迟加载机制来进行查询，如果只调用load方法会返回一个代理对象，对象中只保存了id，不会向数据库发送sql语句，只有当访问了对象的非id属性时，才会向数据库发送sql语句； 2、get()方法只要调用了就会向数据库发送sql语句，查询完成后将对象信息返回来 注：根据id查不到对象：load方法会返回ObjectNotFoundException，get返回null； hql格式：from+类名+类对象+where+对象的属性 sql是面向数据库表查询，格式：from+表名+where+表中字段 HQL是一种面向对象的查询语言，面向Java实体类，与SQL语句没有关系，但是和SQL语句有相同的语法结构； 异同： SQL面向数据库查询，HQL面向Java实体类查询 HQL中不支持SELECT*的写法。 SQL不支持除了分组函数（聚合函数，组函数）以外的其他函数。 HQL语句不支持表的连接查询。 占位符使用，下标从0开始； 普通bean组件：@Component 三个衍生注解：@Repository@Service@Controller 管理bean对象生命周期注解：@PostConstruct初始化方法@PreDestory销毁方法 管理bean对象作用域注解：@Scope DI依赖注入：普通值注入：@Value 引用类型值的输入：@AutoWired（spring自带）@Resource（JavaEE自带） @Qualifier JSP页面传值给Controller处理器： 1、在方法中添加HTTPServletRequest对象 2、在方法中添加参数接受jsp传过来的值 1．请求参数key和方法参数名一致，直接将值传给参数 2.请求参数key和方法参数名不一致，利用@RequestParam（）注解 3、使用实体类对象接受请求参数 1．创建实体类，实体类属性名和请求参数key名称一致 2.在业务方法添加实体对象作为参数，通过实体接受请求参数 Controller处理器传值给JSP页面： 1、在方法中添加HttpServletRequest对象或者session对象 2、在业务方法中添加Model对象或者ModelMap对象，实质上是将值存在request中 3、在参数前添加@ModelAttribute Ajax:异步提交，页面无刷新 1、引入SpringMvc与Ajax交互核心开发包 jackson-annotations-2.9.2.jar jackson-core-2.9.2.jar jackson-databind-2.9.2.jar 2、SpringMvc怎么传值给Ajax 再返回值类前面或方法上加注解@ResponseBody，这样返回的数据就不会走视图解析器， 而是直接返回前端Ajax，前端Ajax会将拿到的数据解析为与JS相对应的类型 String-->string boolean-->boolean bean对象-->object(JSON对象) List-->object(Array) map-->object(JSON对象） 3、Ajax怎么提交值给SpringMvc 1、提交普通请求实体字符串类型到springmvc，springmvc可以直接接受 key1=varlue&key2=value2&.... 2、提交JSON字符串到spring，需要在方法参数中加@RequestBody注解 '{"key1":value1,"key2":value2....}' 3、怎样将表单中数据序列化为JSON字符串 1.导入js/jquery.serializeJson-min.js 2.将表单中数据序列化成json对象 varrequestData=$("form").serialize(); 3.把json对象序列化成json字符串 varjsObj=JSON.stringify(jsonObj); 写一个类实现HandlerInterceptor接口 重写接口中拦截方法： preHandler请求进入处理器之前调用 afterCompletion处理器执行完请求之后调用 postHandle响应返回给浏览器之前调用 1、try{}catch{} 2、全局异常处理器（处理所有controller抛出的异常） 添加全局异常处理器，统一处理项目中异常 3、局部异常处理器（只能处理当前处理器中的异常）： 在当前的处理器中定义一个处理器异常的方法，在方法中添加Exception参数接受异常 在处理方法上添加@ExceptionHandler注解 1、转发到一个JSP页面 返回值String：return“视图名”； 2、由上边原因，SpringMVC的方法之间基本上独立的，独享requestresponse数据，请求数据通过参数获取，处理结果通过ModelMap交回给框架，方法之间不共享变量，而Struts2搞的就比较乱，虽然方法之间也是独立的，但其所有Action变量是共享的，这不会影响程序运行，却给我们编码读程序时带来麻烦，每次来了请求就创建一个Action，一个Action对象对应一个request上下文。3、由于Struts2需要针对每个request进行封装，把request，session等servlet生命周期的变量封装成一个一个Map，供给每个Action使用，并保证线程安全，所以在原则上，是比较耗费内存的。 4、拦截器实现机制上，Struts2有以自己的interceptor机制，SpringMVC用的是独立的AOP方式，这样导致Struts2的配置文件量还是比SpringMVC大。 5、SpringMVC的入口是servlet，而Struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。 6、SpringMVC集成了Ajax，使用非常方便，只需一个注解@ResponseBody就可以实现，然后直接返回响应文本即可，而Struts2拦截器集成了Ajax，在Action中处理时一般必须安装插件或者自己写代码集成进去，使用起来也相对不方便。 7、SpringMVC验证支持JSR303，处理起来相对更加灵活方便，而Struts2验证比较繁琐，感觉太烦乱。 9、设计思想上，Struts2更加符合OOP的编程思想，SpringMVC就比较谨慎，在servlet上扩展。 10、SpringMVC开发效率和性能高于Struts2。11、SpringMVC可以认为已经100%零配置。 （1）Hibernate与MyBatis都是通过SessionFactoryBuider由XML配置文件生成SessionFactory，由SessionFactory生成Session，由Session来开启执行事务和SQL语句。 （2）Hibernate和MyBatis都支持JDBC（JavaDataBaseConnectivity，java数据库连接）和JTA（JavaTransactionAPI，Java事务API（ApplicationProgrammingInterface，应用程序编程接口））事务处理。 注：jdbc和jta的主要作用是增强数据访问能力。 （3）基于ORM（ObjectRelationalMapping，对象关系映射）思想解决了entity和数据库的映射问题 不同点： （1）sql方面：mybaits通过mapper.xml维护映射结果，程序员手动编写sql相比hibernate自动生成hql（hibernatesql）更加灵活，sql调优更加容易（hibernate因为更好的封装性，开发效率提高的同时，sql语句调优要更费力，当然可以手动修改sql来优化，但是同时也会影响开发效率）；hibernate的hql数据库移植性更好，体现在强壮性。hibernate在级联删除的时候效率低；数据量大，表多的时候，基于关系操作会变得复杂。 （2）缓存方面：mybatis和hibernate都可以使用第三方缓存，而hibernate相比maybatis有更好的二级缓存机制。 根据一定的映射规则，根据接口通过动态代理方式自动生成它的实现类 映射规则： 1、映射接口的全限定名必须和映射文件的namespace保持一致 2、映射接口中方法名必须和SQL定义语句的id保持一致 3、映射接口的方法的参数类型和SQL定义的parameterType保持一致 4、映射接口的返回值类型必须和SQL定义的resultType一致 update/delete/insert返回值类型为void 建议规范 1、映射接口名后缀最好以Mapper结尾 2、映射文件放在与映射接口相同的包下面 ajax()方法通过HTTP请求加载远程数据。 该方法是jQuery底层AJAX实现。简单易用的高层实现见$.get,$.post等。$.ajax()返回其创建的XMLHttpRequest对象。大多数情况下你无需直接操作该函数，除非你需要操作不常用的选项，以获得更多的灵活性。 最简单的情况下，$.ajax()可以不带任何参数直接使用。 1.number2.string3.boolean4.undefined5.null6.Object7.symbol