java基础查缺补漏

Buid Path一般包括：JRE运行时库、第三方功能扩展库（*.jar）、其他工程、其他源代码或Class文件。

 

Math.pow(m,n)表示m的n次方

Math.round()表示四舍五入，只保留整数

 

类里定义的数据成员称为属性，属性可不赋初值，若不赋初值则JAVA会为其添加默认值；方法里定义的数据成员称为变量，变量在参与运算之前必须赋初值。

 

Java的数据类型包括基本数据类型、引用数据类型和自定义类型。

（基本数据类型包括byte、short、int、long、float、double、char、boolean，其中boolean作为单个数据类型占4个字节作为数组元素占1个字节）

 

计算机存储数据分为寄存器、栈空间、堆空间，其中java只能直接控制栈空间和堆空间。

栈空间:

存取数据的效率高，仅次于寄存器；

数据按“先进后出”的方式管理；

存储空间较小，不能存放大量的数据；

Jvm(java virtual machine)将基本类型的数据存放在栈空间。

 

堆空间：

存取数据的效率最低；

存放的位置随机分配；

存储数据的空间大，能存放大容量的数据，包括数组、字符串、对象、集合。

 

为什么使用包装类？包装类中封装了一些很实用的方法和常量，包装类在集合中用来定义集合元素的类型。

 

补码的作用：

可以将符号位和其他位统一处理；

最高位不再表示数值，而是作为符号位，正好将数值折半，即一半是0至正数，一半是负数；

减法也可按加法来处理；

 

补码运算的特征：

计算机中正数和负数的关系是取反加一；

补码运算是封闭的，运算结果保留在补码范围之内，超范围就溢出；

4位二进制补码最多能表示2^4（16）个数，数的范围是-8~7；

8位二进制补码最多能表示2^8（256）个数，数的范围是-128~127；

16位二进制补码最多能表示2^16（65536）个数，数的范围是-32768~32767；

32位二进制补码最多能表示2^32个数。

 

Java底层使用一个16位的整数来处理字符类型，该数值是一个字符的unicode编码值。

(char)65:65;èA:65;

 

Switch和if的区别：

5个选项（包括default）的情况下，switch和if/else if相同。低于5个选项if快，高于5给选项switch快；

switch用来根据一个整型值进行多路分支，并且编译器可以对多路分支进行优化；

switch-case只将表达式计算一次,然后将表达式的值与每个case的值比较,进而选择执行哪一个case的语句块；

if..else 的判断条件范围较广，每条语句基本上独立的，每次判断时都要条件加载一次，所以在多路分支时用switch比if..else if .. else结构要效率高。

switch…case只能处理case为常量的情况，对非常量的情况是无能为力的。例如 if (a > 1 && a < 100)，是无法使用switch…case来处理的。所以，switch只能是在常量选择分支时比ifelse效率高，但是ifelse能应用于更多的场合，ifelse比较灵活。 根据不同场合选择不同的语句。

 

This表示类中的属性和调用方法；调用本类中的构造方法（需要将this()放在首行）；表示当前对象。This是对于当前类对象的引用，不能用来调用类方法。

 

类方法，也称静态方法，指的是用static关键字修饰的方法。此方法属类本身的方法，不属于类的某一个实例（对象）。类方法中不可直接使用实例变量。其调用方式有三种：可直接调用、类名.方法名、对象名.方法名。

实例方法指的是不用static关键字修饰的方法。每个实例对象都有自身的实例方法，互相独立，不共享一个。其调用方式只能是对象名.方法名。

 

Static声明属性，表示声明全局属性；使用static声明方法或属性可直接通过类名调用；使用static方法的时候，只能访问static声明的属性和方法，而非static声明的方法不能访问。

声明为静态会在实例化之前调用。

最先执行静态块，静态块优先于主方法；构造块与普通块按位置先后顺序执行；构造块优先于构造方法。

 

方法的重载：

一.方法名一定要相同。

二.方法的参数必须不同，包括参数的类型或个数，以此区分不同的方法体。

1.如果参数个数不同，就不管它的参数类型了！

2.如果参数个数相同，那么参数的类型必须不同。

三.方法的返回类型、修饰符可以相同，也可不同。

 

 

递归调用是一种特殊的调用形式，就是方法自己调用自己。

 

封装性：

目的=====

保护某些属性和方法不被外部所看见。

实现=====

为属性和方法进行封装是通过关键字private声明的。

实现该属性的get和set方法，供外部访问。

 

匿名对象就是没有名字的对象，如果程序中只是用一次该对象，就可以使用匿名对象的方式。如：new Student().tell();

 

构造方法名称必须与类名一致，没有返回值，主要是为类中的属性初始化。每个类在实例化之后都会调用构造方法，如果没有构造方法，程序在编译时会创建一个无参的什么都不做的构造方法。构造方法也可以重载。

 

引用传递：

（String类型的数据不会改变）

 

继承：

只允许单继承；子类不能直接访问父类的私有成员（通过get\set方法使用）；子类对象在实例化之前必须先调用父类中的构造方法，之后调用子类构造方法。

在继承中也存在着重写的概念，就是子类定义了和父类同名的方法。

重写：方法名称相同，返回值类型相同，参数也相同。

被子类重写的方法不能拥有比父类方法更加严格的访问权限。

Super关键字，强行调用父类方法的执行，不只是重写时，也可以表示那些方法是从父类中继承而来的。

重写overriding与重载overloading的区别：

重载的方法名称相同，参数类型或个数不同，对权限没有要求，发生在一个类中；

重写的方法名称、参数类型个数、返回值类型全部相同，被重写的方法不能拥有比父类更严格的权限，发生在继承中。

 

常量一般通过类名调用；

 

Final关键字在java中被称为完结器，表示最终的意思。

Final能声明类、方法、属性：

使用final声明的类不能被继承；

使用final声明的方法不能被重写；

使用final声明的变量会变成常量，常量是不可被修改的。

 

抽象类：

包含一个抽象方法的类就是抽象类；抽象方法是指声明而未被实现的方法，抽象方法必须使用abstract关键字声明；抽象类被子类继承，子类（如果不是抽象类）必须重写抽象类中的所有抽象方法；抽象类不能直接实例化，要通过其子类进行实例化；不要继承已完成好的类。

 

接口：

接口是java中最重要的概念，接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。接口的实现也必须通过子类，使用关键字implements，而且接口是可以多实现的，一个子类可以同时继承抽象类和实现接口；一个接口只能继承一个抽象类，但却可通过extends关键字同时继承多个接口，实现接口的多继承；接口体中定义的方法都自动是抽象、公有的；接口体中定义的常量都自动是public static final；接口访问权限只有两种public和缺省状态；接口中永远不能有实例字段，并且在接口中的方法不会被实现，提供实例字段和方法实现是实现接口的类的任务。

 

接口和抽象类的异同：

接口中所有的方法隐含的都是抽象的，而抽象类则可以同时包含抽象和非抽象的方法；

类可以实现很多个接口，但只能继承一个抽象类；

类如果要实现一个接口，必须要实现接口声明的所有方法，但类可以不实现抽象类声明的所有方法，当然在这种情况下，类必须得声明成抽象的；

抽象类可以在不提供接口方法实现的情况下实现接口；

Java接口中声明的变量默认都是final的，抽象类可以包含非final的变量；

Java接口中的成员函数默认是public的，抽象类的成员函数可以是private、protected或者public；

接口是绝对抽象的，不可以被实例化，抽象类也不可以被实例化，但如果它包含main方法是可以被调用的。

 

多态性：

体现在方法的重载和重写、对象的多态性。

对象的多态性：

向上转型è程序会自动完成   父类  父类对象=子类实例

          B extends A à Aa=new B();à通过a可以调用A中的方法，若A中方法被B重写，则执行被B类重写的方法。

向下转型è强制类型转换     子类  子类对象=（子类）父类实例

         B extends A à A a=new B();  B b=(B)a;à通过b可以调用A和B中的所以方法，但若A中方法被B重写，则执行被B类重写的方法。

多态性的应用：

A   tell()  à B extendsA    C extends A    Dextends A

调用A中tell方法à创建say(A a)方法à执行a.tell()àmain方法中调用say(new B())或say(new C())或者say(new D())

Instanceof关键字可用来判断一个对象到底是不是一个类的实例，从而调用其属性和方法。

 

泛型可以解决数据类型的安全性问题，主要原理是类声明的时候通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。常用大写的T表示泛型。

class Point<T>{} àPoint<Integer> p=new Point<Integer>();Point<String> p=new Point<String>();

构造方法中使用泛型：构造方法可以为类中的属性初始化，那么如果类中的属性通过泛型指定，而又需要通过构造方法设置属性内容时，那么构造方法的定义与之前并无不同，不需要像声明类那样指定泛型。

泛型的通配符为?àPoint<?>

不仅仅可以声明泛型类，也可以声明泛型接口，声明泛型接口和声明泛型类的语法类似，也是在接口名称后加<T>；格式为：interface 接口名称<泛型标识>{}

泛型方法中可以定义泛型参数，参数类型就是传入数据类型。

格式：访问权限 <泛型标识> 泛型标识方法名称（[泛型标识参数名称]）

àpublic <T>T tell(T t){}

àpublic <T>void tell(T arr[]){}à泛型数组，调用方法arr[]可以自定义数据类型，如StringInteger

 

集合可以理解成一个动态的对象数组，不同的是集合中的对象内容可以任意扩充；

集合的特点：性能高、容易扩展和修改；

Collection接口的常用子类：List、Set、Queue

List接口可以存放任意的数据，而且在List接口中内容是可以重复的；

List接口常用子类:ArrayList、Vector；ArrayList在JDK1.2之后推出，采用异步处理方式，性能高，属于非线程安全；Vector在JDK1.0推出，采用同步处理方式，性能低，属于线程安全。

List接口常用操作：是否为空isEmpty()、指定对象是否存在indexOf()。

Set接口中不能加入重复元素，但可以排序；

Set接口常用子类：散列存放HashSet、有序存放TreeSet；

Iterator接口à集合输出的标准操作：使用Iterator接口；

Iterator的操作原理：专门的迭代输出接口，迭代输出就是将元素一个个进行判断，判断其是否有内容，如果有内容则把内容取出;迭代输出时不能通过集合对象进行移除操作。

操作Iterator时，使用remove方法如下：Iterator<String> iter=lists.iterator(); iter.remove();而不能采用集合lists进行remove操作。

Map接口以keyàvalue方式保存

Map的常用子类HashMap、HashTable。

 

File文件

File file=new File(“text.txt”);   File nameto=new File(“new Hello.txt”);

创建文件         file.createNewFile()

删除文件         file.delete()

文件重命名       file.renameTo(nameto)   (同一分区可用于移动)

判断文件是否存在file.exists()

读取文件名称     file.getName()

读取文件路径     file.getPath()

读取文件绝对路径file.getAbsolutePath()

获取文件父级路径 file.getParent()

读取文件大小     file.length()+”byte”  ((float)值除以1000则可得到KB值)

文件是否被隐藏   file.isHidden()

文件是否可读     file.canRead()

文件是否可写     file.canWrite()

判读是否为文件   file.isFile()

设定文件可写     file.setWritable(true)

设定文件可读     file.setReadable(true)

设定文件只读     file.setReadOnly()

File文件夹

File folder=new File(“my new folder”);  File newfolder=new File(“my new folders”);

创建文件夹       folder.mkdir()  (创建多重文件夹时所有文件夹必须全部存在)

创建文件夹       folder.mkdirs()  (可创建多重文件夹)

判读是否为文件夹file.isDirectory()

文件夹是否存在   folder.exists()

文件夹重命名     folder.renameTo(newfolder)(同一分区可用于移动)

删除文件夹       folder.delete() (所删除的文件夹中必须为空，不存在任何文件或文件夹)

遍历文件夹的方法：

public void printFiles(File dir){

         if(dir.isDirectory()){

                   Filenext[]=dir.listFiles();

                   For(inti=0;i<next.length;i++){

                            System.out.println(next[i].getName());

                            If(next[i].isDirectory ()){

                                     printFiles(next[i]);

}

}

}

}

文件的简单读写：

FileInputStream fis=newFileInputStream(file);

InputStreamReader isr=newInputStreamReader(fis,”UTF-8”);

BufferedReader br=new BufferedReader(isr);

String line=br.readLine();//读取行

其中需要catch异常，并按顺序关掉流br\isr\fis

FileOutputStream fos=newFileOutputStream(newfile);

OutputStreamWriter osw=newOutputStreamWriter(fos,”UTF-8”);

BufferedWriter bw=new BufferedWriter(osw);

bw.writer(“一二三四五六\n”);

其中需要catch异常，并按顺序关掉流bw\osw\fos

 

IO体系的基本功能就是读和写。

根据数据走向分为输入流、输出流。根据处理的数据类型分为字节流、字符流。

字节流：可以处理所有类型的数据，在读取时，读到一个字节流就返回一个字节；对应的类都以Stream结尾；

字符流：仅能够处理纯文本数据，如txt文本，读取时读到一个或多个字节，先查找指定的编码表，然后将查找到的字符返回；对应的类以Reader或Writer结尾；

字节：通过网络传输信息或在硬盘或内存中存储信息的单位，是计算机技术用于计量存储容量和传输容量的一种计量单位；1个字节等于8位二进制，即一个8位的二进制数，是一个具体的存储空间；如OX01、OX45。

字符：人们使用的记号，抽象意义上的一个符号；如“中”、“1”、“a”、“$”;

字符集：也称作“编码”，各个国家和地区所制定的不同ANSI编码标准中，都只规定了各自语言所需的“字符”。这些ANSI编码标准所规定的内容包含两层含义：使用哪些字符，所包含字符的集合就叫字符集；规定每个字符分别用一个字节还是多个字节存储，用哪些字节来存储，这个规定就叫编码。

各个国家和地区在制定编码标准时，“字符的集合”和“编码”一般都同时制定。因此平常我们所说的字符集除了有字符的集合这含义外，也包含了编码的含义。

ANSI：系统预设的标准文字存储格式，不是具体的某一种编码，不同国家和地区使用不同的标准。字符串在内存中，如果字符是以ANSI编码形式存在，一个字符可能使用一个或多个字节来表示，则称为ANSI字符串或者多字节字符串。不同ANSI编码所规定的标准是不同的，因此需要知道采用哪种编码规则才能知道包含哪些字符。如“中文123”（若以GB2312表示，则占7字节，中文占两个字节）。

UNICODE:为是国际间信息交流方便，国际组织制定了UNICODE字符集，为各种语言中的每一个字符设定了统一并唯一的数字编号，以满足跨语言、跨平台进行文本转换、处理的要求。字符串在内存中，如果字符是以UNICODE中的序号存在的，称为UNICODE字符串或者宽字节字符串。无论在什么环境下所代表的字符内容总是不变的。用来给UNICODE字符集编码的标准有很多种，如UTF-8\UTF-7\UTF-16\UnicodeLittle\UnicodeBig等。如：L”中文123”（L表示采用UNICODE编码，占10字节）。

字节流 FileInputStream  FileOutputStream

字符流 InputStreamReader OutputStreamWriter

读取文件字符FileReader  FileWriter

BufferedInputStream带缓冲区的字节输入流BufferedOutputStream带缓冲区的字节输出流

带缓冲区的字符流 BufferedReader BufferedWriter(无换行) PrintWriter(有换行)【可能问题】—如果写出的数据没有填满缓冲区，则缓冲区中内容可能不会写出，导致文件不完整或丢失，则close前需要使用flush方法，若使用PrintWriter，则还可以采用PrintWriter  pw=newPrintWriter(osw,true);

RandomAccessFile随机文件读写，用于多线程的下载和文件传输

 

线程：程序中单独顺序的控制流，线程本身依靠程序进行运行，只能使用分配给程序的资源和环境；

进程：执行中的程序，一个进程可以包含一个或多个线程，至少要包含一个线程；

单线程：程序中只存在一个线程，实际上主方法就是一个主线程；

多线程：在一个程序中运行多个任务，目的是更好的使用CPU资源；

线程实现的2种方式：继承Thread类、实现Runnable接口；（都必须重写run方法）

线程的启动是通过start方法执行的，不通过run方法执行（run方法和之前的通过对象去调用方法无区别）；

方法都在Thread中

线程的状态：

创建状态              准备好了一个多线程的对象

就绪状态              调用了start()方法，等待CPU进行调度

运行状态              执行run()方法

阻塞状态              暂时停止执行，可能将资源交给其他线程使用

终止状态（死亡状态）  线程销毁

线程常用的方法：

取得线程名称  getName()

取得当前线程对象  currentThread()

判断线程是否在执行  isAlive()

线程的强行运行  join()

线程的休眠      sleep()

线程的礼让      yield()

线程的优先级（有可能影响线程的执行顺序）：

1àMIN_PRIORITY

10àMAX_PRIORITY

5àNORM_PRIORITY(如果不设置，默认为5)

线程同步：（资源共享问题）

同步代码块à在代码块上加上synchronized关键字，此代码块称为同步代码块

同步代码块格式  synchronized(同步对象){需要同步的代码块}

同步方法à方法也可同步  synchronized void 方法名称(){}

死锁指多个进程循环等待它方占有的资源而无限期地僵持下去的局面；

终止线程的方法：

使用退出标志，使线程正常退出，也就是当run方法完成后线程终止；

使用stop方法强行终止线程（这个方法不推荐使用，因为stop和suspend、resume一样，也可能发生不可预料的结果）；

使用interrupt方法中断线程，分为两种情况：（1）线程处于阻塞状态，如使用了sleep方法。   （2）使用while（！isInterrupted（））{……}来判断线程是否被中断。

 

XML

可扩展标记语言，是一种标记语言，很类似HTML；设计宗旨是传输数据，而非显示数据；标签没有被预定义，需要自行定义标签；被设计为具有自我描述性；是W3C的推荐标准。

Xml和html的区别：

Xml不是HTML的替代；二者为不同目的而设计；

Xml被设计为传输和存储数据，其焦点是数据的内容；

HTML被设计用来显示数据，其焦点是数据的外观；

HTML旨在显示信息，而xml旨在传输信息。

Xml的特点：

仅仅是纯文本；没有预定义的标签；所有的元素都必须有关闭标签；

Xml标签对大小写敏感；必须正确嵌套；文档必须有根元素；属性值必须加引号；空格会被保留。Xml元素可包含其他元素、文本或者两者的混合物，元素可以拥有属性。

Java读取xml：（DOM方式）

Java创建xml文件：（DOM方式）

Dom4j操作xml文档：

String xmlString=”<root><people>ACELY</people></root>”;

Documentdocument=DocumentHelper.parseText(xmlString);

System.out.println(document.asXML());

 

JSON简介：是存储和交换文本信息的语法。是轻量级的文本数据交换格式，独立于语言和平台，具有自我描述性、更容易理解。

JSON和XML类似，但比XML更小、更快、更易解析。没有结束标签；更短；读写的速度更快；使用数组；不使用保留字。

JSON语法是JavaScript对象表示法语法的子集。数据在名称/值对中，数据由逗号分隔，花括号保存对象，方括号保存数组。

 

使用HTTP的get方法读取网络数据：

新建线程类继承Thread，重写其run方法。

使用HTTP的post方法读取网络数据：

新建线程类继承Thread，重写其run方法。

使用httpclient进行get方式与网络通信：使用Apache的HttpComponents

使用httpclient进行post方式与网络通信：使用Apache的HttpComponents

新建线程类继承Thread，重写其run方法。

 

Socket

又称“套接字”，应用程序通常通过“套接字”向网络发出请求或者应答网络请求。Java中，socket和serversocket类库位于java.net包中。Serversocket用于服务器端，socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个socket实例，操作这个实例，完成所需的会话。对于一个网络链接来说，套接字是平等的，并没有差别，不因为在服务器端或客户端而产生不同级别。不管是socket还是serversocket的工作都是通过socket类及其子类完成的。

Socket链接的建立过程：服务器监听、客户端发出请求、建立链接、通信。

Socket特点：基于TCP链接，数据传输有保障；适用于建立长时间链接；编程通常应用于即时通讯。

 

JSP

表达式的语法格式：<%= 表达式 %>

脚本程序的语法格式：<% 代码片段%>

声明的语法格式：<%! 可以声明一个或多个变量、方法，供后面的Java代码使用%>

注释：<!--  HTML注释，该注释在源文件中可查看 -->

<%--  jsp注释，源文件中看不到注释内容--%>

<%

//源文件中看不到注释内容

/*源文件中看不到注释内容*/

%>

指令：

<%@ page ... %>    定义页面的依赖属性，比如脚本语言、error页面、缓存需求等等

<%@ include ... %>  包含其他文件

<%@ taglib ... %>     引入标签库的定义，可以是自定义标签

JSP内置对象：

Out:向客户端浏览器输出信息；

Request:封装来自客户端浏览器的各种信息，同时负责管理输出缓存区；

Response:封装服务器的响应信息；

Exception:封装JSP程序执行过程中的异常和错误信息；

Config:封装应用程序的配置信息；

Page:指向当前JSP程序本身；

Session:用来保存会话信息，可以在同一用户的不同请求之间共享信息；

Application:代表应用程序的上下文，可以在不同用户之间共享信息；

pageContext:提供对jsp页面所有对象及命名空间的访问。

 

Servlet

Servlet 生命周期可被定义为从创建直到毁灭的整个过程。以下是 Servlet 遵循的过程：

Servlet 通过调用 init () 方法进行初始化。

Servlet 调用 service() 方法来处理客户端的请求。

Servlet 通过调用destroy() 方法终止（结束）。

最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。

 

jsp和servlet的区别和联系：

1.jsp经编译后就变成了Servlet.(JSP的本质就是Servlet，JVM只能识别java的类，不能识别JSP的代码,Web容器将JSP的代码编译成JVM能够识别的java类)

2.jsp更擅长表现于页面显示,servlet更擅长于逻辑控制.

3.Servlet中没有内置对象，Jsp中的内置对象都是必须通过HttpServletRequest对象，HttpServletResponse对象以及HttpServlet对象得到.

Jsp是Servlet的一种简化，使用Jsp只需要完成程序员需要输出到客户端的内容，Jsp中的Java脚本如何镶嵌到一个类中，由Jsp容器完成。而Servlet则是个完整的Java类，这个类的Service方法用于生成对客户端的响应。

联系：  JSP是Servlet技术的扩展，本质上就是Servlet的简易方式。JSP编译后是“类servlet”。Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。JSP侧重于视图，Servlet主要用于控制逻辑。

 

MVC模式：

Model（模型）是应用程序中用于处理应用程序数据逻辑的部分。通常模型对象负责在数据库中存取数据。

View（视图）是应用程序中处理数据显示的部分。通常视图是依据模型数据创建的。

Controller（控制器）是应用程序中处理用户交互的部分。通常控制器负责从视图读取数据，控制用户输入，并向模型发送数据。

 

三层架构

分别是表现层（UI）、业务逻辑层（BLL）、数据访问层（DAL）。

分层的目的是为了高内聚，低耦合、便于更改维护。

表现层（UI）：通俗讲就是展现给用户的界面，他担当者接受用户信息和给用户显示用户信息的功能，即用户在使用一个系统的时候他的所见所得。

业务逻辑层（BLL）：针对具体问题的操作，也可以说是对数据层的操作，对数据业务逻辑处理、最明显的就是三大语句、判断、循环、多分支、这个一定是在逻辑层的。

数据访问层（DAL）：该层所做事务直接操作数据库，针对数据的增添、删除、修改、更新、查找等。

 

SSH------Struts+spring+hibernate

从职责上分为四层：表示层、业务逻辑层、数据持久层和域模块层。

使用Struts作为系统的整体基础架构，负责MVC的分离，在Struts框架模型部分，控制业务跳转，利用hibernate框架对持久层提供支持，spring做管理，管理Struts和hibernate。具体做法是：用面向对象的分析方法根据需求提出一些模型，将这些模型实现为基本的Java对象，然后编写基本的DAO(Data Access Objects)接口，并给出Hibernate的DAO实现，采用Hibernate架构实现的DAO类来实现Java类与数据库之间的转换和访问，最后由Spring做管理，管理struts和hibernate。

基本业务流程是：

在表示层中，首先通过JSP页面实现交互界面，负责接收请求(Request)和传送响应(Response)，然后Struts根据配置文件(struts-config.xml)将ActionServlet接收到的Request委派给相应的Action处理。

在业务层中，管理服务组件的SpringIoC容器负责向Action提供业务模型(Model)组件和该组件的协作对象数据处理(DAO)组件完成业务逻辑，并提供事务处理、缓冲池等容器组件以提升系统性能和保证数据的完整性。

而在持久层中，则依赖于Hibernate的对象化映射和数据库交互，处理DAO组件请求的数据，并返回处理结果。

 

SSM（Spring+SpringMVC+MyBatis）框架集成Spring、SpringMVC、MyBatis。