java基础都在这了，小主们拿去吧

欢迎大家来到IT世界,在知识的湖畔探索吧!

—–面向对象———

面向对象和面向过程的区别？

面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描述某个事务在整个问题中的行为。

面向过程是分析出解决问题所需要的步骤，然后用方法一步一步实现出来，使用的时候依次调用就可以了

面向对象的优点？

程序结构清晰，自动生成框架，减少程序维护量，代码重用率高

封装？

是将对象有关数据和行为封装成整体来处理

类和对象的区别？

类是指同一类型的对象的抽象描述

类是抽象的，对象是具体的

类的数据称为成员变量，类对数据的操作称为成员方法

方法的构成？

访问修饰符，返回类型，返回值，方法名，形参

同一类不同的对象？

同一类不同的对象的成员变量占用不同的内存空间

同一类的不同对象共同享用该类的方法

对象的创建？

对象的创建用new关键字，也叫实例化

传值和传引用？

传值：是栈内存新生的一个变量，然后把值赋给基本类型叫做传值

传引用：只是在栈内存声明的一个对象句柄，然后指向传来的对象，对象类型的参数叫做传引用。

构造方法？

构造方法和类名相同，构造器可以是任何访问修饰符，public private protected 或者没有访问修饰符，不能用非访问修饰符修饰，比如：static 、final、synchronized abstract都不能修饰构造方法

构造方法总是伴随着new一起使用

方法的重载？overload

一个类中多个方法拥有相同的名字，在名字相同时必须有不同的参数，1.参数个数不同，或者对应位置上的参数不同

this关键字？

this是当前对象自己，当成员变量和局部变量重名时在方法中使用this.表示当前对象的成员变量

继承？extends

新定义的类是从已有的类中获取属性和方法的现象，java只支持单继承

Super？

表示当前对象的父类对象的一个引用，可以调用当前对象父类的方法，也可以调用当前对象的父类的构造函数

Super和this的区别？

Super和this类似，super是从子类中调用父类的构造方法，this是在同一类中调用其他方法

方法的重写？ Overwrite和override

在子类中可以根据需要对从基本类型superclass中继承来的方法进行修改，重写的必要条件：方法名必须相同，方法参数列表比偶徐相同，访问权限必须大于等于父类的方法，返回值和父类一致，

多态？ Ploymorphis

动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法

多态的必要条件：要有继承，要有重写，父类引用指向子类对象

多态的好处：可替换性、可扩充性、接口性、灵活性、简化性

多态的强制转换：向上转型一定是成功的，向下转型比一定成功，比如所有的狗一定是动物，所有的动物不一定是狗，父类引用如果直接调用父类中没有子类中独有的方法会报错，需要先转为子类对象再调用，或者在父类中加上该方法，否则报错。

Static？

表示全局或者静态的意思，用来修饰成员变量和成员方法，也可以形成静态代码块，不能修饰局部变量。

final？

可以修饰类、方法、和变量（包括成员变量和成员方法）。当用final修饰一个类时这个类不能被继承，final方法无法被子类覆盖，可以被子类使用，如果是static final声明的常量必须在声明的地方赋值。

Hashcode？哈希码

是一种编码方式，每个对象都有一个hashcode，可以通过hashcode来识别一个对象，hashcode相等对象未必相等，hashcode可以对应多个对象

equals和==的区别？

基本数据类型之间用==比较的是它们的值，引用数据类型比较的是内存地址，除非用同一个new出来的对象它们比较的结果相同则为true，否则为false，java中所有的类都继承与object类，在object类中定义了equals方法，这个方法的初始行为是比较对象的内存地址。

当equals被重写时要重写hashcode方法，以维护hashcode常规协定，该协定声明相等对象必须具有相等的哈希码。

tostring

java中所有类都继承于object，object中有tostring方法

抽象类？abstract

abstract修饰符修饰的类叫抽象类，，包含抽象方法的类一定是抽象类，抽象类的方法全部可以是抽象方法也可以是普通方法，抽象类的子类必须实现父类的抽象方法，如果没有实现父类的抽象方法也要声明为抽象类，抽象类不能被实例化。

接口？interface

接口是比抽象类还要抽象的抽象类，因为java不支持多重继承，所以有了接口，接口可以继承多个接口，，一个类只能继承一个父类，可以实现多个接口，接口不能实现另一个接口，但可以继承多个接口，类如果实现了一个接口必须实现接口里所有的抽象方法，否则定义为抽象类

接口和抽象类的区别？

接口只能定义静态常量属性，抽象类可以定义普通属性，也可以定义静态常量属性，接口只能包含抽象方法，抽象类可以包含已经实现的具体方法，接口不能包含构造方法，抽象类可以包含构造方法

——-异常————

异常？Exception

指不期的各种情况，如文件找不到、网络连接失败，非法参数等，异常是一个事件，它发生在程序运行期间，干扰了正常指令流程。

异常分类：Error，这种异常被设计为不捕获，因为产生于jvm本身

Exception：运行时异常，受检查异常

Runtime Exception： 运行时异常往往与环境有关，编译时无法检查，并且可能发生的情况太广泛，由于效率问题，允许程序不对其处理， 系统会处理，不需要捕获。

Checked Exception：受检查异常要么用try…catch捕获，要么throws语句抛出，

否则编译不通过，，例如：IOxEception、ClassNotFoundException

运行时异常和受检查异常的区别？

Java编译器不检查运行时异常，但是检查受检查异常，运行时异常往往是程序员自己造成的，正确的方法是进行捕获，恢复程序运行，受检查异常是指程序员已经足够小心的检查了代码，但不能保证代码不出异常

异常没有得到处理的情况下怎么办？

如果每个方法都是简单的抛出异常，那么在方法调用的多层嵌套中，java虚拟机也会出现异常，如果出现异常的线程为主线程，则整个程序运行终止，如果非主线程，则终止该线程其他程序继续运行。

IO流

将数据从源（文件、内存、键盘、网络）读取到内存中形成了流，然后将这些流写到另一个目的地，（文件、内存、控制台、网络）。

流的形象表示？

Java中的流是分辨输入输出流，是站在程序员的角度

什么是反射？为什么要用反射？

反射是在我们还没写好被调用的时候可以利用反射机制来调用逻辑探知方法

线程和进程的区别？

进程：一个进程可以启动多个线程，每个进程都有独立的内存空间

线程：是进程中的一个执行流程，是进程中某个单一顺序的控制流

进程是资源分配的最小单位，线程是CPU调度的最小单位，进程中的多个线程共享进程的内存，

进程和线程的对比？

线程和进程相比，线程是一种花销小切换快更节俭的操作方式，启动一个线程所花费的空间小于启动一个进程所花费的空间，线程之间方便通信机制，进程不方便通信， 线程是同一进程下的线程之间共享数据空间，一个线程的数据可以直接为其他线程使用，方便，快捷，但不安全

多线程的有点？

程序响应快，单CPU资源利用率更好，多CPU的系统更加有效，改善程序结构

线程的5种状态

新建状态、就绪状态、运行状态、阻塞状态、死亡状态

多线程下数据不安全问题？

临界资源：一次只允许一个进程（线程）使用的共享资源为临界资源，多线程访问临界资源会发生线程不安全问题。

线程同步

多个线程对共享资源同时访问时必须持有对方的锁才允许访问共享资源，java中提供了synchronized关键字，每个访问临界资源的方法必须同步，保证线程持有锁才能进入该方法访问临界资源，每个对象只有一把锁

锁对象的方法

Synchronized（方法名）或者public synchronized 方法名

线程死锁

两个对象相互锁着对方，谁都不肯放掉已经锁上的对象就没有了结果，叫做线程死锁。

产生死锁的条件：至少一个资源不能被共享，至少有一个任务必须持有一个资源并且等待获取另一个被识别的任务持有资源

线程通信

notify notifyAll wait 主要是用来让线程之间互相通知事件的发生

wait和sleep的区别？

Sleep是抱着锁睡觉，wait是抱着锁等待，sleep是thread里的方法，在执行的时候锁不会被交出去，直到sleep的所有方法执行完毕后才交出锁。

Wait是object里的方法，在被执行的时候锁被解除，直到notify或notifyAll方法唤醒。

Notify：也是object的方法，用于唤醒此对象等待的线程，如果很多线程被挂起，就随机唤醒一个线程。

notifyAll：是唤醒所有线程，最好用notify方法。

Collection 和 Map的 区别

Collection表示一组对象，这些对象是collection的元素，collection提供了更具体的子接口，如set和list，set中的元素无序并且不可重复，List中的元素有序并且可重复。

集合中的重复是判断两个对象的equals。

Map 定义了一键一值的方式存取对象，一个映射不能包括重复的键，每个键只能映射一个值，一一对应。Map值实现了hashMap和reeMap

ArrayList

1.实现原理：ArrayList是数组实现的List， LinkedList是基于链表的数据结构

2.随机访问：ArrayList通过get和set方法对元素进行随机访问，LinkedAList随机访问比较慢

3.新增和删除：LinkedList比较占优势，向ArrayList中插入与移除元素速度很慢

hashSet

是set接口的实现类，不保证顺序，重复元素不被添加，基于hashMap实现的

hashMap

hashMap是基于哈希表的，Map的实现是一个Entry数组，Entry对象包含了键和值，是用来处理hash冲突的形成一个链表，hashMap是非线程安全的，如果想要线程安全可以通过collections的静态方法synchronizedMap获得线程安全的hashMap。

hashtable和hashMap区别？

Hashtable是dictionary的子类，hashMap是map接口的一个实现类，hashtable中的方法是同步的，hashMap中的方法在缺省的情况下是非同步的，hashMap效率高，hashtable效率低

TreeMap

实现原理：TreeMap类实现了Map接口还实现了Map的子接口，不允许键对象为null，因为集合中的映射关系是根据键对象一定顺序排列的。

LinkedhashMap

LinkedhashMap是hashMap的子类，实现原理是双向链表

LinkedhashMap维护的是一个具有双向链表的hashMap，支持两种排序，一种是插入排序，一种是使用排序，LinkedhashMap输出时是随机的，如果Map映射比较复杂而要求高效率最好使用LinkedhashMap，但是多线程访问可能造成不同步，所以要用

collection. synchronizedMap（）;方法来包装一下，实现同步。

——-网络编程——–

OSI TCP/IP模型

OSI:物理层—>数据链路层—>网络层—>传输层—>会话层—>表示层—>应用层

TCP:应用层—>传输层—>网络层—>网络接口

IP协议

用于将多个包交换网络连接起来。IP的责任是把数据从源传送到目的地，不负责保证传送可靠性，流控制，IP实现两个功能：寻址、分段。

TCP和UDP

TCP和UDP协议属于传输层协议，提供了IP环境下的数据可靠性传输，提供的服务包括数据流传送，可靠性（三次握手），有效流控，全双IP操作，多路复用。

UDP：不为IP提供可靠性，流控或差错恢复功能，TCP对应的是可靠性要求高的应用，而UDP对应的是可靠性低传输经济的应用。

TCP和UDP的区别？

TCP协议面向连接、传输慢、保证数据顺序和正确性、对系统资源要求多

UDP协议面向无连接、传输快、不保证数据顺序和正确性、对资源要求少

Soket

网络上的程序通过一个双向的通信连接实现数据的交换，连接的一端称为soket，soket的意思是孔或者插座，是取后的意思，也成套接字，用于描述IP地址和端口通信的句柄，可以用来实现不同虚拟机或不同计算机之间的通信，

TCP soket

基于TCP（面向连接），的soket编程，分为客户端和服务端

服务端的流程：

1． 创建一个serversoket实例并指定本地端口用来监听客户端在该端口发送TCP连接请求

2． 重复执行：

1. 调用server的accept（）方法以获取客户端连接并通过其返回值创建一个soket实例

2. 为返回的soket实例开启新的线程，并返回soket实例的IO流与客户端通信

3. 通信完成后使用soket类的close方法关闭该套接字连接

客户端的流程：

1. 创建一个soket实例，构造函数指向的远程主机和端口建立一个TCP连接

2. 通过套接字的IO流与服务端通信

3. 使用soket类的close方法关闭连接

视图

在SQL中视图基于SQL，语句的结果集的可视化的表，视图包含行和列，就像一张真实的表。

视图的作用：视图能够简化用户的操作，能够使用户能以多种角度看待同一数据，视图对重构数据库提供了一定程度的逻辑独立性，视图能够对机密数据提供安全保护

存储过程

是在大型数据库中，经过第一次编译后再次调用不需要再次编译，如果该存储过程带有参数用户通过指定存储过程的名字并给出参数来执行。

优点：java语法不好实现的代码，用过程写会比较简单，而且过程一次编译就可以运行，执行效率高。

触发器

触发器是一些过程，当发生在特定的数据库事件时就执行这些过程，用触发器扩充完整性。

truancate和delete的区别？

truancate删除比delete快，因为delete命令删除的数据将存储在系统回滚中，需要的时候数据可回滚恢复，而truancate命令删除的数据是不可恢复的。

三大范式

1NF：原子性，字段不可再分

2NF:字段完全依赖于主键（消除部分依赖）

3NF:消除传递依赖

SQL优化

1. 表明顺序，把关联表放最后，基础表放前面

2. Where语句的连接顺序，可以过滤大量记录的条件，语句放到where语句的最后面，关联条件语句放到最前面

3. 尽量避免使用*

4. 尽量使用decode 函数，减少处理事件

5. 删除重复记录最有效的方法，借助物理ID

6. 用truancate代替delete

7. 尽量多实用commit，commit会尽量释放资源，释放回滚上的信息，程序语句的锁。

8. Where语句代替having语句，条件语句执行顺序，先 on后再where最后having，能被放到where的过滤条件绝不放到having里面

9. 使用表别名，每个列之前加上别名，减少由列的歧义引起的语法错误

10. 尽量使用大写，Oracle在执行SQL语句的时候先转成大写再执行。

数据库的事务

每一个逻辑执行单元执行的操作要么全部成功，要么全部失败

数据库事务的4个特性

原子性：要么全部执行，要么全部失败

一致性：保持底层数据存储的完整性

隔离性：事务必须在不干扰其他进程或事务且不被打扰的前提下独立执行

持久性：事务执行过程中对数据的修改必须在事务成功结束之前保存到物理设备。

连接池

数据库连接池负责分配管理和释放数据库连接，允许应用程序重复使用一个现有的数据库连接，释放空闲时间

连接池原理：是在系统化的时候将数据连接作为对象存储在内存中

JDBC数据库连接池必须实现Datesource接口，datesource也成为数据源，该数据源有三种：

C3p0连接池，DBCP连接池 ，Proxool连接池

代码分层：C：控制层（controller）底层是servlet负责控制请求返回结果

V：view（jsp）

M：模型层，model（通常包括业务逻辑层Biz层和持久层Dao）

控制层访问业务逻辑层（Biz）业务逻辑层（Biz）访问数据访问层（Dao）数据访问层返回给业务逻辑层并返回给控制层。

Servlet的执行流程

Servlet被部署到web容器中当客户端发送调用servlet请求时会判断servlet的实例是否存在，如果存在就直接创建一个线程，不存在 则先装载该servlet再调用构造方法创建实例，其次再次调用实例的init方法，这个方法只会在servlet初始化的时候调用一次，除非servlet重新部署，每一次调用创建一个线程，再根据请求的具体类型调用doGet和doPost方法，然后生成动态的回复内容，最后服务器发送回复内容给客户端的浏览器，当 servlet不需要再使用的时候就会被卸载掉，卸载前调用destory方法完成所有相关资源释放。

Ajax

是异步的JavaScript和XML

同步发送ajax请求的情况

如果使用同步方法发送请求在后台反馈结果回来之前页面出于阻塞状态，前台页面无法操作，直到后台反馈回来才能操作页面

创建对象，发送请求，响应请求结果，反馈内容

Jsp运行原理

像普通网页浏览器发送一个Http请求给服务器，web服务器识别出这是一个对jsp网页的请求并且将该请求传递给jsp引擎，通过使用URL或者jsp文件来完成，jsp引擎从磁盘中转载jsp文件，然后转化为servlet，并且将所有元素转化为java代码，jsp由web容器生成对应的servlet的java文件和class文件放入Tomcat的work目录下，jsp网页是一种方式编写的servlet，主要是为了帮助servlet解耦合。

Jsp编译指令

Page include taglib

动作指令

forWord param include piugin useBean setProperty getProperty

jsp内置对象

request response session application out pageContext config page Exception

MVC:（model view controller）

MVC的优点

一个时间专门关注一方面，简化了分组开发，在改进和个性化定制页面及交互时不需要重新编写业务逻辑

设计创建web应用程序的模式

Model：用于处理应用程序数据逻辑部分，模型对象负责在数据库中存取数据

View：用于处理数据显示部分，视图是一句模型数据创建的

Controller：处理用户交互部分，控制层负责从视图读取数据，控制用户输入，并向模型发

送数据

action接收参数

Struts是用action接收参数，action采用简单数据类型属性接收参数，需提供Set方法，通过反射set方法来获取请求参数的值

拦截器 AOP核心

在AOP中用于某个方法或字段被访问之前进行拦截，然后在之前或之后加入某些操作，拦截器是AOP的一种实现策略

Hibernate

是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，将POJO与数据库建立映射关系，是一个全自动orm框架，Hibernate可以自动生成SQL语句自动执行，使得java程序员可以随心所欲的使用面向对象编程思想来操纵数据库，Hibernate可以应用在任何JDBC场合，也可以在servlet和jsp中使用，Hibernate对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性饭吗，Hibernate是基于JDBC的主流持久层框架很大程度的减少了Dao层的编码工作，是一个轻量级框架，支持很多关系型数据库，从一对一到多对多的各种复杂关系

Hibernate对象的状态：

临时状态、持久化状态、游离状态

临时状态：仅内存有

持久化状态：内存有，session缓存有，数据库也有

游离状态：内存无，session缓存有，数据库也有

Getcurrentsession和opensession的区别

如果打算使用Getcurrentsession，上下文使用的地方也要用session，从上下文找，有就用旧的，没有用新的

Opensession：每次调用该方法得到的是一个新的session，opensession获得的session需要手工关闭

延迟加载

是需要的时候才执行SQL语句，进行查询，避免了无谓的性能开销。

类级别的查询策略：

如果class元素中的lazy属性默认为true表示采用延时加载，若果为false表示立即加载，通过session的load方法在配置文件中配置class标签，lazy属性为false表示立即加载

JPA:持久化

通过jdk5.0注解或XML描述对象关系表的映射关系

HQL

Hibernate提供了query接口专门HQL查询接口，能够执行各种复杂的SQL语句

缓存：用的是Ehcache

一级缓存：是session级别的缓存，

二级缓存：跨session的sessionFactory级别的缓存

开启二级缓存的步骤：

开启查询缓冲:<property name=”cache.use.query>true”

开启二级缓冲：<property name=”cache.use.second>true

添加配置文件：ehcache.xml”

在使用缓冲的类前面加上注解@cache

单session即一级缓存

事务范围的缓存只能被当前事务访问，每个事务都有自己的缓存，缓存内的数据通常采用相互关联的对象方式，缓存的生命周期依赖于事务的生命周期，只有当事务结束时缓存的生命周期才会结束。

单sessionFactory即二级缓存

应用程序的缓存可以被应用范围内所有事务共享访问，缓存的生命周期依赖于应用的生命周期，只有当应用结束后缓存的生命周期才会结束。

二级缓存是如何工作的？

Hibernate的二级缓存和一级缓存相同，也是针对对象ID来进行缓存，二级缓存的作用范围是根据ID获得对象的查询。在执行各种条件时如果获取的结果为实体类集合那么就会把所有的数据对象根据ID放入二级缓存中。

在通常情况下将具有一下特征的数据放入缓存二级缓存中：

1. 很少被修改的数据

2. 不是很重要的数据，允许出现偶尔并发的数据

3. 不会被并发访问的数据

4. 常量数据

5. 不会被第三方修改的数据

不适合放在二级缓存中的有：

1． 经常被修改的数据

2． 财务数据，绝不能出现并发

3． 与其他应用共享的数据

==================Spring================================

1. spring功能模块 IOC AOP

1.IOC 控制反转

什么是DI？

Dependency Injection(依赖注入)：对象无需自行创建和管理它们的依赖关系，依赖关系被自动注入到需要他们的对象中去

DI的好处：

DI带来的最大的收益是松耦合，代码变得简单，并且容易测试

IOC和DI的区别？

1. 它们是Spring核心思想的不同方面的描述

2. IOC控制反转：是创建对象实例的控制权从代码控制，剥离到IOC容器控制，实际在XML文件控制，侧重于原理

3. DI依赖注入：创建对象实例时为这个对象注入属性值或其他对象实例，侧重于实现

2. 第一个程序

Spring多种类型应用上下文

AnnotationConfigApplicationContext

AnnotationConfigWebApplicationContext （web专用）

ClassPathXmlApplicationContext

XmlWebApplicationContext

注：单击测试使用ClassPathXmlApplicationContext

1. 导入jar包

2. 在service 层加入Dao层的成员变量，并提供Setter方法

3. 加入配置文件ApplicationContext.xml并修改配置属性，加入bean的配置

4. 获取bean的实例

5. 注入方式：构造方法注入：

bean scopes：

singleton: 单例，获得beanFactory时全部实例化bean

prototype: 多例，通过getBean调用时实例化

request: 一次请求有效

Session: 一次会话有效

Application: 当前生命周期内有效

默认是singleton，singleton是加载配置文件的时候实例化所有bean，bean的scopes改为prototype那么每次getBean都要实例化一次，并且调用一次setDao方法（注入）,实例化的顺序是先实例化子bean，再实例化父bean,修改为prototype获取的bean比较，不同。

XML自动装配 Autowired：

自动装配SpingIOC容器自动检查BeanFactory的内容来替我们指定bean的关系，有了自动装配可以不用再配bean的依赖关系。

自动装配类型：

autowire=” byType”

autowire=”byName”

1.在bean的标签上加default-autowire=”byType”或default-autowire=”byName”

2.使用setter方法注入

3.同一类型的实现类只能提供一个bean的配置，否则抛出异常

Lazy-init

Lazy-init=”true”，默认是false，改为true配置文件加载后默认不实例化bean，将实例 加载到内存里面，可以达到节约内存的目的

全局：default-lazy-init=”false”, default-lazy-init=”true”，就近一致原则，按照false执行

1.@Autowired自动装配

有了自动装配可以不用再配置依赖关系，但bean还是需要配置

1. 先添加xsd文件

2. 添加<context:annotation-config>

3. 在要被注入的set方法前加入@Autowired,如果不提供setter方法也可以在属性上添加

4. 默认会通过byName方法找，如找不到就按类型找

5. 如果按类型找，找多个类型（按名字找例外），相同的就会报错，此时需要指定国定名称才能装配成功

2.@Resource 自动装配

1. @Resource 需要导入import javax.annotation.Resource包

2. @Resource(name=””)，可以指定依赖bean的name，【注意：会带来一定的侵入性】

@Autowired和@Resource的区别？

1. 都可以用来装配bean，都可以写在字段上或者setter方法上

2. 都是按名字装配，默认按名字装配

3. @Autowired默认是按名字装配，这个注解属于spring的，默认情况下必须要求依赖对象必须存在，如果允许null值可以设置它的required属性为false

4. @Resource注解是属于J2EE的，默认按照名称进行装配，名称可以通过name属性指定，如果没有指定name属性，当注解写在字段上时默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配，当找不到与名称相符匹配的bean时才按照类型进行装配，需要注意的是如果name属性一旦指定就会按照名称进行装配，建议使用@Resource注解在字段上，且这个注解是属于J2EE的，减少了与spring的耦合，最重要的是这样的代码看起来比较优雅。

Component-scan

组件扫描：搜索指定目录下的类用IOC的注入类或者当AOP切面类

1. 配置文件加入<context:component-scan base-package=”包名”/>

2. 在被依赖的类名前加入@Component

3. 在需要依赖的地方加入@Resource

4. 如果需要有两个实现类都在同以包名目录下，那么不需要指定名字

AOP 面向切面思想

1. 什么是代理？

a) 可以增加一些实例外的功能

2. 动态代理：

相比静态代理的优势是不用被代理类实现同一接口，也不为每个类生成一个固定的代理类，可以用于任何实现接口的类

3. AOP的概念：

面向切面编程可以预编译方式和运行期动态代理实现不修改源代码的情况下给程序动态统一添加功能的技术

4. AOP和OOP的对比

面向对象的特点是：封装、继承、多态，而封装就要求将功能分散到不同的对象中去，这在软件设计中往往成为职责分配，实际是让不同的类设计不同的方法，这样代码就分散到一个个类中了，这样做的好处是降低了代码的复杂程度，使类可以重用，但是也发现在分散代码时也增加了代码的重复性，这种在运行时动态的将代码切入到类的指定方法，指定位置上的编程思想叫做面向切面编程，AOP是OOP的补充，OOP从横向上区分出一个个类来，而AOP则是从纵向上向对象中特定的代码，有了AOP之后OOP变得立体了，如果加上时间维度，AOP使OOP原来的二维变成三维，由平面变成立体，从技术上说：AOP是通过代理机制实现的。

5.AOP的XML 编程

1.加入jar包

2.加入aop配置，配置文件中加入aop的schema

6.AOP的注解编程

1.加入配置

//组件扫描实现切面

<context:component-scan base-package=”包名”/>

//合并

<context:component-scan base-packeage=”包名/>

//默认使用jdk动态代理，实现AOP编程

<aop:aspect –autoPyoxy>

2.aop包

3.在代理的切面方加入注解

在代理开始前加入@Component

在代理结束后加入@@Aspect

4.@Around 要接入形参 ：proceedingJoinPoint procee

5@Around 方法的优先级高于@Before 、@Aftor

Sping 声明式事务

1. 定义事务管理bean

<bean id=”transactionManager” class=””/>

2. 添加schema

3. 配置事务传播特性，将事务固定到方法上

事务通知:<tx:advice id=”txAdive” tranction-Manager=”tranctionManager”/>

4. 指定事务边界点（切入点）

<aop:config>

5. 测试时候必须使用currentSesssion

6. 在service层写业务逻辑，方法名和和配置文件中的一致，否则不加入事务，不要捕获异常，否则破坏事务

Spring声明式事务，注解实现

1. 添加配置开启spring注解事务

<tx:annotation-driven truncation-manager=”trancationManager”/>

2. 在需要添加事务的方法上加注解，@Transational 也可以在类名前加

Spirng事务总结：

Spring声明式事务提问

1. 你们框架事务怎么管理的？

答：spring的声明式事务，1.sessionFactory 2.TrancationManager 3.通知边界

2. 什么是spring声明式事务？用的什么原理？

答：就是配置文件夹配置事务边界（切入点），利用AOP原理动态切入到指定的业务逻辑方法中

3. spring声明式事务的事务边界设置在哪一层？

答：Biz层或者service层

4. 事务用哪个session？

答：用getCurretSession保证多个dao操作共享一个连接

5. 要不要捕获异常？

答：只要抛出运行时异常spring会帮我们自动回滚，如果手工捕获异常，事务不会回滚，破坏事务一致性

6．声明式事务和编程式事务的区别？

答：声明式事务利用面向切面编程思想，编程更灵活、更简洁，没有大量获 取连接和提交回滚的代码

========================SpringMVC==============

1. springMVC的介绍

springNVC是一种基于java实现的web mvc设计模式的请求驱动类型的轻量级框架，即使用MVC架构模式的思想将web层进行职责解耦

2.SpringMVC 能帮我们做什么？

让我们能非常简单的设计出干净的web层和薄薄的web层，

1. 进行更简洁的web层开发

2. 天生与spring框架集成（IOC、AOP）

3. 提供了强大的大于配置

4. 能简单的进行web层单元测试

5. 支持灵活的 URL到页面控制器的映射

6. 非常容易的与其它视图技术集成

7. 非常灵活的数据验证，格式化和数据绑定机制，能使用任何对象进行数据绑定

8. 提供一套强大的jsp标签库，简化jsp开发

9. 支持灵活的本地化，主题解析

10. 更简单的 异常处理

11. 对静态资源的支持

12. 支持restful风格

3.Struts2和springMVC 的区别？

1.Struts2是类级别的拦截，一个类对应一个上下文，springMVC 是方法级别拦截，

一个方法对应一个request上下文，而方法同时又和一个url对应，从框架本身上SpringMVC容易实现restful URL，而Struts2的架构实现起来要费劲，因为

Struts2中action的一个方法啊可以对应一个URL，而其类属性却被所有方法共

享，这也就无法用注解或其他方法标识其所属的方法了。

2.Struts2需要针对每一个request进行封装，把request、session等生命周期

封装成一个map放入值栈，供给每个action使用并保证线程安全，所以从原则

上比较耗费内存

3.ringMVC的参数绑定是从方法级别，而Struts2是成员变量来绑定，所以从灵活性和可读性都不如springMVC

4.拦截器实现机制上Struts2有以自己的intercept机制，springMVC用的是独立的AOP方式，这样导致Struts2的配置文件量比springMVC大

5.SpringMVC的入口是servlet，而Struts2是filter,这要指出filter和servlet是不同的

6.SpringMVC集成了ajax，使用非常方便，只需要一个注解@ResourceBody就可以实现，然后直接返回响应文本即可，而Struts2拦截器集成了ajax，在action中处理时一般需要安装插件或者自己写代码集成进去，使用非常不方便

7.springMVC验证支持JSR303,处理起来更加灵活方便，而Struts2验证比较繁琐，感觉太烦乱

8.springMVC和spring是无缝的，从这个项目管理和安全上高于Struts2

9.设计思想上Struts2更加符合OOP编程思想，SpringMVC比较谨慎，在servlet上扩展

10.springMVC开发效率高于Struts2

11.springMVC可以认为100%零配置

方法：

1. 导入jar包

2. 配置中央控制器，在web.xml文件中配置

3. 添加schema

4. 添加springmvc-servlet.xml文件，在文件中配置控制器、映射器、适配器、视图解析器

5. 编写控制器类实现controller接口并实现HandlerRequest方法

6. 添加页面