Java代码的基本知识
500 Internal Server Error//服务器内部错误
32、 描述Web应用中用声明方式来进行错误处理的两种方法
使用error-page元素声明一个给定HTTP状态码的处理器
404
/error/404.html
可以声明任意数量的错误页面，但一个给定的状态码只能对应一个页面
使用exception-type元素声明给定Java异常的处理器
java.lang.ArithmeticException
/error/ExceptionPage
可以声明任意数量的错误页面，但一个给定的异常类型只对应一个页面
不能使用父类捕获多种异常
33、 描述记录异常日志的方法，都位于那些接口?
GenericServlet：
log(message:String)
log(message:String, Throwable:excp)
ServletContext：
log(message:String)
log(message:String, excp:Throwable)
34、 什么是会话?
Web容器可为每个用户保存一个"会话对象"，用来存储特定用户的会话信息。
35、 如何获得会话?
HttpSession session = request.getSesseion( );
36、 会话Api的基本功能?
getID() :String
isNew() :boolean
getAttribute(name):Object
setAttribute(name,value)
removeAttribute(name)
37、 如何销毁会话?
1、可使用部署描述符控制所有会话的生命周期
10
2、可使用控制特定会话对象的生命周期HttpSession接口
invalidate()
getCreationTime() :long
getLastAccessedTime() :long
getMaxInactiveInterval() :int
setMaxInactiveInterval(int)
38、 描述会话保持状态的基本原理
client server
request
response (sessionid)
request (cookies)
当客户端第一次请求时，服务器创建一个session与request绑定，用响应对象response来返回sessionid 放到客户端的cookies中存储下来，下次在发送请求时，直接根据sessionid来检索服务器的会话(每次请求都会将所有的cookies带到服务器端)
39、 请描述session和cookie的异同之处
40、 如何读写cookie，代码示例
写： Cookie c = new Cookie("yourname", name);
response.addCookie(c);
读：Cookie[] cookies = request.getCookies();
for ( int i=0; i < cookies.length; i++ ) {
String key =cookies[i].getName();
String value = cookies[i].getValue();
System.out.println("cook"+i+":key="+key+",value="+value);
}
41、 什么是URL重写，如何实现，代码示例
Cookie不能使用时，可使用URL重写 request.encodeURL();
客户在每个URL的后面追加额外的数据
服务器将此标识符与其存储的有关会话数据相关联
http://host/path/file;jsessionid=123
42、 描述web应用的4种认证技术
BASIC – Web浏览器接收用户名和口令，将其以明码方式发送给Web服务器
DIGEST – Web浏览器接收用户名和口令，使用加密算法将此数据发送给Web服务器
FORM – Web应用提供发送给Web浏览器的HTML form
CLIENT-CERT – Web容器使用SSL验证用户，服务端和客户端的链路保护
43、 什么是授权，什么是验证?
授权是根据用户角色划分web资源的过程，其标识web应用中的安全域 分配权限
web容器使用厂商指定的机制验证用户的角色 匹配权限
44、 什么是HTTPS
HTTPS (Secure Hypertext Transfer Protocol) 是使用SSL协议的HTTP
45、 什么是审计?
也就是访问跟踪，是为web应用的每次访问保留记录的过程
46、 如何实现声明性授权
1、标识web资源集
2、标识角色
3、将web资源集影射到角色
4、标识每个角色中的用户
在 web.xml里配
47、 描述servlet并发问题?
多个同类线程运行，可以共享同一个Servlet实例，共享的数据和资源未合理同步，可能会引起数据的冲突
48、 描述Web应用中的六种属性范围
局部变量(页面范围)
实例变量
类变量
请求属性(请求范围)
会话属性(会话范围)
上下文属性(应用范围)
49、 指出上述六种哪些是线程安全的
局部变量和请求属性
50、 什么是STM?如何实现?
SingleThreadModel接口
可以实现SingleThreadModel接口保证某一时刻只有一个请求执行service方法
51、 如何实现并发管理?
尽可能使用局部和请求属性
使用synchronized语法控制并发
尽可能减少同步块和同步方法的使用
使用正确设置了线程安全的资源类
Jsp
1、 什么是Jsp?
Java Server Page 结合java和html在服务端动态生成web页面的技术
2、 描述Jsp页面的运行过程?
第一步：
请求进入Web容器，将JSP页面翻译成Servlet代码
第二步：
编译Servlet代码，并将编译过的类文件装入Web容器(JVM)环境
第三步：
Web容器为JSP页面创建一个Servlet类实例，并执行jspInit方法
第四步：
Web容器为该JSP页面调用Servlet实例的_jspService方法;将结果发送给用户
3、 描述Jsp页面的五类脚本元素的功能、写法、并示例
注释
指令标记 指令标记影响JSP页面的翻译阶段
声明标记 声明标记允许JSP页面开发人员包含类级声明
脚本标记 脚本标记允许JSP页面开发人员在_jspService方法中包含任意的Java代码
表达式标记 表达式标记封装Java运行时的表达式，其值被送至HTTP响应流 Ten is
4、 描述Jsp页面中的注释种类和写法
HTML注释
JSP页面注释
Java注释
5、 描述Jsp页面的指令标记的功能、写法、并示例
指令标记影响JSP页面的翻译阶段
6、 描述Jsp页面的声明标记的功能、写法、并示例
声明标记允许JSP页面开发人员包含类级声明
写法：
例：
7、 描述Jsp页面翻译成Servlet的规则
jsp中的注释标记被翻译成Servlet类中的注释
jsp中的指令标记被翻译成Servlet类中的import语句等
jsp中的声明标记被翻译成Servlet类中的属性
jsp中的脚本标记被转移到Servlet类中service方法中的代码
jsp中的表达式标记被翻译成Serlvet类中的write()或者print()方法括号中的代码
8、 描述Jsp页面的九个预定义变量的功能、用法、并示例
request 与请求相关的HttpServletRequest对象
response 与送回浏览器的响应相关的HttpServletResponse对象
out 与响应的输出流相关的JspWriter对象
session 与给定用户请求会话相关的HttpSession对象，该变量只在JSP页面参
与一个HTTP会话时有意义
application 用于Web应用的ServletContext对象
config 与该JSP页面的servlet相关的ServletConfig对象
pageContext 该对象封装了一个JSP页面请求的环境
page 该变量与Java编程语言中的this变量等价
exception 由其它JSP页面抛出的Throwable对象，该变量只在"JSP错误页面"中可用
9、 page指令的功能，写法、并示例，并描述它的如下属性的功能和用法：import、session、buffer、errorPage、isErrorPage、ContentType、pageEncoding
import import 定义了一组servlet类定义必须导入的类和包，值是一个由
逗号分隔的完全类名或包的列表。
session session 定义JSP页面是否参与HTTP会话，值可以为true(缺省)
或false。
buffer buffer 定义用于输出流(JspWriter对象)的缓冲区大小，值可以为
none或Nkb，缺省为8KB或更大。
errorPage 用来指定由另一个jsp页面来处理所有该页面抛出的异常
isErrorPage 定义JSP页面为其它JSP页面errorPage属性的目标，值为true或
false(缺省)。
ContentType 定义输出流的MIME类型，缺省为text/html。
pageEncoding 定义输出流的字符编码，缺省为ISO-8859-1
10、 描述MVC各部分的功能?MVC的优点?MVC的缺点?
MVC各部分的功能：
Model(模型表示企业数据和业务逻辑)
封装应用状态
响应状态查询
暴露应用的功能
Controller(控制器接受用户的输入并调用模型和视图去完成用户的需求)
验证HTTP请求的数据
将用户数据与模型的更新相映射
选择用于响应的视图
View(视图是用户看到并与之交互的界面)
产生HTML响应
请求模型的更新
提供HTML form用于用户请求
MVC的优点：
低耦合性：视图层和业务层分离
高重用性和可适用性
较低的生命周期成本
快速的部署
可维护性
有利于软件工程化管理
提高软件的健壮性
MVC的缺点：
工作量大，增加工作的复杂性，MVC不适合小型甚至中等规模的应用程序
11、 什么是Model 1结构，以及结构中各部分的功能
结构：jsp+javabean
Model1中使用jsp来处理web应用中的视图控制部分
Javabean收集参数
12、 什么是JavaBean?
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。
13、 JavaBean的规则?
使用get和set方法定义属性
一个无参构造方法
无public实例变量( 所有属性私有化)
14、 什么是jsp标准动作?包含那些?分别都是什么功能?如何使用?
JSP页面中使用类似于XML的标记表示运行时的动作
jsp:useBean
jsp:setProperty
jsp:getProperty
jsp:param
jsp:include
jsp:forward
15、 用代码示例如下标准动作的使用：useBean、getProperty、setProperty
id="myForms"
class="com.base.mystruts.forms.MyActionForm" scope="session" />
16、 描述说明Bean的四种scope
page
request
session
application
17、 描述说明页面上的字段和Bean中属性的对应规则
id 指javabean的变量名
class指javabean类的全路径
scope指javabean的应用范围
name指所用到的javabean的变量名
property指javabean中的属性
18、 描述useBean动作的处理过程
使用id声明变量
试图在指定的范围内查找对象
如果没找到
创建一个类的实例
执行useBean标记体初始化对象
如果找到
将对象转换为类指定的类型
19、 描述forward动作的功能
使用脚本代码处理请求时，可用jsp:forward 动作产生一个不同的视图，
使用同一个request：
20、 什么是Model 2结构，以及结构中各部分的功能
jsp+model+servlet
Model 2架构使用MVC模式，JSP页面充当视图，Servlet充当控制器
Servlet控制器：
验证HTML form数据
调用模型中的业务服务
存储请求(或会话)范围内的域对象
选择下一个用户的视图
JSP页面视图：
使用用户界面(在HTML中)
访问域对象
21、 如何获得分发器?分发器的功能?
上下文对象中的分发器：
ServletContext context = this.getServletContext();
RequestDispatcher servlet = context.getNamedDispatcher("MyServlet");
servlet.forward(request, response);
请求对象中的分发器：
RequestDispatcher view = request.getRequestDispatcher("tools/nails.jsp");
view.forward(request, response);
可以将请求转发到另一个jsp页面，并保持请求的传递性
22、 Jsp中页面跳转的两种方式?
使用分发器跳转页面
RequestDispatcher dispatcher = request.getRequestDispatcher(“url”);
dispatcher.forword(request);
特点：保持请求的传递(上一次请求中的数据，在下一个请求中仍然可以得到);
转发的页面只能是同一个Web应用程序的其他Web组件
使用重定向跳转页面
response.sendRedirect(“url”);
特点：产生全新的请求，(上一次请求中的数据，在下一个请求中不能得到);
重新定向的页面可以是任意的URL
23、 描述Jsp中引入另外页面的两种方法，并比较两种方法的特点?
在编译期间把另一个页面完全嵌入这个页面,可以说是一个页面
在这里可以共享变量
动态的再运行期间把另一个页面加入这个页面,可以说是两个
页面，不可以共享变量
24、 什么是自定义标记
自定义标记库是一个Web组件，
包括：
一个标记库描述符文件(*.tld)
所有相关的标记处理器类(*.jar)
25、 描述使用自定义标记的步骤，以及每步详细的工作
使用自定义标记前，要拿到.tld和.jar两类文件
1、 把.jar文件放到WEB-INF的lib里面。
2、 把.tld文件放到WEB-INF根目录下。
3、 在web.xml中配置。
http://java.sun.com/jsp/jstl/core
/WEB-INF/c.tld
4、 在页面中引用。
uri必须与web.xml中的uri对应
prefix是前缀，用来区分是哪一个taglib
使用标记
格式：
在tomcat下配置数据源
1、服务器与数据库的连接
配置server.xml文件
1.oracle
factory="org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory"
url="jdbc:oracle:thin:@127.0.0.1:1521:orcl"
driverClassName="oracle.jdbc.driver.OracleDriver"
username="aa"
password="aa"
maxActive="50"
maxIdle="10"
maxWait="-1"
/>
2.sqlserver
factory="org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory"
url="jdbc:jtds:sqlserver://localhost:1433;SelectMethod=cursor;
DatabaseName=webpagetest"
driverClassName="net.sourceforge.jtds.jdbc.Driver"
username="aa"
password="aa"
maxActive="50"
maxIdle="10"
maxWait="-1"
/>
2、配置自己的web应用的xml文件
privileged="true" antiResourceLocking="false" antiJARLocking="false">
3、配置web.xml文件
与服务器建立连接
jdbc/company
javax.sql.DataSource
Container
4、在应用程序中不直接与数据库连接，通过DataSource连接池建立连接
//1.在程序单独用时设置系统的属性，在tomcat下可以不用配置，
System.setProperty(Context.PROVIDER_URL,"");
System.setProperty(Context.INITIAL_CONTEXT_FACTORY,"");
//2.创建一个上下文对象
InitialContext context = new InitialContext();
//3.通过上下文对象在连接池中查找DataSource
DataSource ds = (DataSource)context.lookUp("java:comp/env/jdbc/company");
//4.通过数据源建立连接
ds.getConnection();
Struts2
1、 struts2简介
struts2是一种基于MVC(Model View Controller )的web应用框架。
struts2包括三个部分：struts和xwork，对其他框架或技术的支持
struts处理web相关的部分，xwork处理web无关的部分。
2、 描述基本的struts应用的组成部分以及每部分的功能，并指出哪些是需要开发人员做的
1) struts ActionContext Clear Up ：负责清空ActionContext，确保不会出现由于内存引起的并发问题。
2) other Filters ：其他的过滤器
3) Filter Dispatcher ：struts2的总调度类，通过http请求到ActionMapper询问请求的Action是否执行
4) ActionMapper ：决定这个action需要被执行
5) ActionProxy：找ConfigurationManager要Action的配置，然后产生Action Invocation对象
6) ConfigurationManager：响应ActionProxy的请求找到xwok.xml
7) struts.xml ：通过配置让 Action 调用器 调用Action
8) Action Invocation：调用对应的Action
9) Interceptor ：拦截在Action和result执行前后完成一些功能(比如将request中的数据映射到值栈中)
10) Action ：处理客户端请求，调用逻辑层API，通过Result选择下一界面
11) Result：常量字符串
12) 页面：通过Taglib的标签 得到值栈中的数据并显示
13) Taglib： 得到封装对象中的数据
需要开发的有：Action，页面(配置上Taglib的前缀，用OGNL得到数据)，struts.xml，如果要解决中文问题还要配置 struts.properties文件
3、 描述struts开发的步骤，以及每步具体的工作
见教材第二章
4、 描述从页面点击一个按钮开始，完整的Struts应用运行过程
1) 用户点击页面的提交按钮，即客户端发送http请求到web容器。
2) web容器通过web.xml找到web容器的Filter;通过url-pattern 找到filter-name，再通过filter-name找到filter-class，即找到FilterDispatcher。
3) Action代理调用ConfigurationManager读取xwork.xml文件，根据提交的xx.action,找到对用的action的全路径，通过Action调用器调用Action类。
4) 在调用Action类之前，首先被配置拦截到，进行相关的处理，如将request中的数据映射到值栈中。
5) 回调Action中的execute方法，执行后返回Result。
6) 得到Reslut后，在xwork.xml中匹配下一个页面。
7) 执行Result调用下一个页面。
5、 图示描述struts的架构
6、 为什么推荐使用ActionSupport
因为ActionSupport不仅实现了Action接口，而且实现了其他的接口，例如：validate()方法-数据检验，getLocal()获取本地信息等功能
7、 Struts中数据检测的方式有几种，详细写出分别怎么做
1、在validate()方法中进行数据检验
2、在execute()方法中进行数据检验，但一定要有返回值为INPUT
8、 Struts中如何使用本地信息
1、和Action类同级新建一个与Action同名的.properties文件，并用key，value定义好组件对应的信息(国际化信息)
2、在Action类中使用：this.getText("key")
9、 详细写出struts的Action中三种数据的对应方式，并比较优缺点
1、域模型：灵活，封装数据， public 或 private+get/set
2、字段驱动：把字段直接封装在Action中，适用于字段少的程序
3、模型驱动：Action类实现ModelDriver接口，并实现getModel方法，页面上直接用返回对象的字段就可以，但一个Action只能对应一个Model
10、 什么是Result
result是一个字符串常量，他表示Action执行完成的状态，struts.xml根据返回的result选择下一个界面
11、 写出通用Result中dispatch,redirect和chain的特点
1、dispatch：保持同一请求，保持数据的传递
2、redirect：重定向，一个全新的请求，丢失数据
3、chain;保持数据的传递，但不是同一请求(一个全新的请求)
12、 Interceptor的功能和运行特点
能在Action和Result执行前后完成一些功能;也可以把Action的共性功能分离出来，以便以后发生变化便于修改，不用动很多的类
13、 配置Interceptor要注意什么，什么是Interceptor栈
注意：以后自定义的Intercepter要追加到defaultStack后——即自己定义一个栈把默认栈和自定义的Intercepter追加上
多个Interceptor构成Interceptor栈
14、 什么是OGNL
OGNL是Object-Graph Navigation Language的缩写，它是一种功能强大的表达式语言(Expression Language，简称为EL)，通过它简单一致的表达式语法，可以存取对象的任意属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转化等功能。它使用相同的表达式去存取对象的属性。
15、 代码示例：在struts中向session中取值和赋值
Action向session中取值：
ServletActionContext.getRequest().getSession().getAttribute("nowPage");
赋值：
ServletActionContext.getRequest().getSession().setAttribute("nowPage",nowPage);
页面向session中取值：
16、 代码示例：在struts中定义集合，并取值和赋值
17、 简述值栈的原理
1、值栈与request绑定，而且是线程安全的
2、值栈相当于一个小型的数据库
3、struts所有的Action属性值存取都通过值栈
18、 如何在struts中取得HttpSession的数据
(1)取得HttpRequest对象：
HttpServletRequest request = ServletActionContext. getRequest();//这个方法返回了与当前线程的ActionContext相关联的request
(2)取得HttpSession对象：
HttpSession session = ServletActionContext. getRequest().getSession();
19、 描述如何使用验证框架的步骤和每步应做的工作
使用验证框架的方法特别简单：
(1)写validatiors.xml文件，注册要用到的验证器
(2)写类名-validation.xml文件，并放到相应的地方
(3)开启Action的验证功能，在xwork.xml文件中指定拦截“validation”或者“validationWorkflowStack”，示例：
注意：不管验证是否通过，我们的Action都会执行，但如果验证没有通过，它不会调用Action的execute()方法
20、 set标签是用来做什么的，描述set标签支持的作用域
功能：对值栈中的表达式进行求值，并将结果赋给特定作用域中的某个变量
下面来看个例子：
每次都要重复#session[‘user’]不仅是麻烦，而且容易出错，较好的方式是：定义一个临时变量来代替它。
作用域的说明： Set标签支持5种作用域：default(也是默认的，ActionContext)，page,request,session,application。通常我们不需要管，除非你要把一个标签或者servlet集成到struts中。
21、 代码示例：property、set、Iterator、bean、param、if、else标签的用法
偶数行
奇数行
ORM对象关系型数据库映射
(Object Relation Mapping)
一、映射的特点
1.一个对象可以对应多个表
2.一个表可以对应多个对象
3.对象和表的关系不用完全对应
4.对象的属性的名称和表字段的名称可以不同
5.类型可以不同，但数据类型之间可以转换
6.对象中必须有主键，数据库的表对主键无所谓
7.数据库中有主外键关系时，对象中可以有，也可以没有
二 、有一个映射的描述文件————>xml
三 、怎样实现描述文件————>一段程序
对象 映射(mapping) 数据库
user
id=11
name="张三"———— > (1) —————> tbl_user(id,name,age,tel,address)
age=25 <————(2) <————
(1)从对象映射到数据库
1.JDBC
2.根据描述文件来动态拼接sql
3.执行，添加到数据库中
(2)从数据库中映射到对象
1.JDBC
2.拼接查询sql
3.ResultSet
4.Model
hibernate
开发流程：
1、 是什么?
hibernate是一种基于orm 的轻量级的框架
2、 有什么?
1. session 保持连接状态(依赖事务和连接池)
2. Transaction事务
3. Connection Provider 连接池
3、 能干什么?
1.orm
2.提供操作数据库的接口，简化数据持久化的编程任务
4、 怎么做?
1.搭建hibernate的运行环境，将hibernate的包和hibernate所需要的包拷贝到lib 文件夹下
2.O(vo)
3.R (关系型数据库中的表)
4.配置文件
4.1 cfg.xml 放在classes根目录下，默认名字为hibernate.cfg.xml
a.与数据库的连接
b.可选配置
c.映射资源的注册
4.2 hbm.xml文件 名字与类名相同 并且与类放在一起
a. 对象与数据库表之间的映射
b. 对象的属性与数据库表的字段之间的映射
c.组件之间的映射
d.对象与对象之间的关系映射
5、客户端
1.得到SessionFactory
2.通过SessionFactory 工厂来创建Session实例
3.打开事务
4.操作数据库
5.事务提交
6.关闭连接
运行流程：
5、 整体流程
1.通过configuration来读cfg.xml文件
2.得到SessionFactory 工厂(根据数据库的连接来创建sessionfactory)
3.通过SessionFactory 工厂来创建Session实例
4.打开事务
5.通过session的api操作数据库
6.事务提交
7.关闭连接
6、 save
1.to--->po
2.根据model和cfg.xml中映射文件的注册来找到hbm.xml文件
3.根据hbm.xml文件和model来动态的拼sql
4.客户端提交或者刷新内存
5.执行sql，值放到数据库
7、 update、
1.根据model 的id在内存hibernate的缓存中查找该对象
如果内存中没有就到数据库中查找来保证对象的存在
2.根据model和cfg.xml文件中映射文件的注册来找到hbm.xml文件
3.根据model和hbm.xml 文件来动态拼sql
4.客户端提交或者刷新内存
5.执行sql
8、 Query
load
1.根据model的类型来找到hbm.xml文件
2.判断id对应的对象在缓存中是否存在，如果存在，就直接使用，如果不存在就进行下一步。
3.用id做为查询条件来动态拼sql
4.执行sql 查询(先在内存中查找，如果没有找到(会抛出例外)，就去数据库中查找)
5.返回一个model类型的对象
get
1.根据model的类型来找到hbm.xml文件
2.用id做为查询条件来动态拼sql
3.执行sql 直接在数据库中查找，如果没有查到就会返回null
query
1.分析hql语句，得到model的类型
2.根据moedel和cfg.xml文件中映射文件的注册找到hbm.xml文件
3.根据model和hbm.xml文件来动态拼sql
4.执行sql查询数据库
5.返回一个resultset
6.循环resultset的值，放到model中在放到集合(List)中
谈谈hibernate缓存机制
缓存其实很直观的理解为放到内存或者硬盘上的一块区域，缓存就是一个缓冲的作用，有很多时候，我们的数据需要经常访问，如果放到数据库中，不是不可，只是效率上低，如果有了中间产物来代替数据库，就省很多事情了。打个比方，去买酱油，不一定一定要去酱油的生产工厂去买。代码中需要数据的时候，可以先到缓存中查找，如果存在，就直接拿数据，不存在就去数据库中取，也省了很多事。
hibernate使用的是二级缓存，有两个级别，分别是Session，SessionFactroy级别，一级缓存是Session级别的缓存，Hiberante来管理的，这个我们一般不用管，二级缓存是SessionFactory级别的，可以进行配置和更改，加载卸载，就是我们平时用的hibernate配置文件中的配置SessionFactory的属性。
对一级缓存中的session事务进行数据的预存取，数据在各个session的上下文中存在(单例)，当session关闭时，就是session.close( )，整个所有session范围内的数据全部清空;二级缓存默认的情况下是不开启的，数据库汇总的所有数据都先copy到二级缓存中，这里要注意的是，一级缓存是每个线程下创建的session缓存区域，可以是多个，二级缓存只有一个区域 ，画个图比较容易理解。
| 一级session缓存| | 一级session缓存| |一级session缓存| |一级session缓存|
| | | |
| | | |
---------------------------------------------------------------------------------------------------
sessionFactroy级别的二级缓存
-------------------------------------------------------------------------------------------------------------------
|
|
|
------------------------------------------------------------------------------------------------------------------
DB
-----------------------------------------------------------------------------------------------------------------
Spring
1、 是什么?
Spring是基于JEE的轻量级的应用框架
2、 有什么?
每个包的功能：
Spring MVC：spring 本身提供的web 框架
WEB：集成其他的web 应用的框架，或者说是对其他web应用框架的支持。如struts，struts
JEE ：集成一系列的jee的技术(对JEE技术的支持)
DAO：封装了JDBC;(对JDBC的支持)
ORM：提供了对ORM工具的集成(支持)
AOP ：面向切面编成
CORE：spring的核心包，提供bean的工厂和IOC容器
3、 能干什么?
把一系列的jee的技术有效的组合在一起形成以良好的系统
4、 怎么用?
1、 搭建web工程，引入spring的jar包
2、 在web.xml中添加如下配置
contextConfigLocation
classpath*:applicationContext*.xml
struts2
org.apache.struts2.dispatcher.FilterDispatcher
struts2
/*
org.springframework.web.context.ContextLoaderListener
3、 部署
5、 容器和bean
Ioc容器是Bean实例的容器，类似于一个实例池，Ioc容器对Bean进行实例化、配置及管理(控制Bean的生命周期及相互的关系)。
Ioc容器与jee的容器类比:
Jee:提供组件的运行环境和管理组件的生命周期(不能单独存在)
Ioc容器:提供bean的运行环境和管理bean的生命周期(可以单独存在)
Bean是受Spring Ioc容器管理(控制)的对象，这些对象除了代表类实例本身，还可以包含各种资源，比如文件、图片、集合、数组、数字、字符串等一切外部资源。
6、 IOC控制反转
Spring的ioc中最重要的两个类是ApplicationContext和BeanFactory
在使用Ioc容器之前，应用程序总是通过工厂，主动索取需要的资源(bean)，比如表现层通过调用逻辑层的工厂得到逻辑层接口的实例，这样做层与层之间就会耦合。
当使用Ioc容器之后，应用程序由主动索取变成被动等待，由Ioc容器控制应用程序需要的资源对象，应用程序只需要做相应的配置声明，说明需要什么bean资源，Ioc容器就可以给应用程序注入相应的资源了。
程序的控制权由应用程序转到了Ioc容器，应用程序由“主动控制”转换成了被Ioc容器控制，控制权发生了转移，所以是控制反转;应用程序依赖Ioc容器的注入才可以运行，所以称为依赖注入。控制反转、依赖注入，方向不同，但描述的却是同一件事情。
好处：
使程序模块化，真正实现松散耦合
使程序可装配
使代码可重用
代码开发：
容器：
BeanFactory是Spring IoC容器的实际代表者，通过BeanFactory的对象可以对Ioc容器中的bean进行管理。
BeanFactory的创建过程是：先读取BeanFactory的配置文件(FileSystemResource或ClassPathResource)，再创建BeanFactory的实例(XmlBeanFactory)。
容器实例化bean的三种方法：
构造器实例化
静态工厂实例化
class="examples.ExampleBean2"
factory-method="createInstance"/>
实例工厂实例化
bean id="myFactoryBean" class="...">
...
factory-bean="myFactoryBean"
factory-method="createInstance"/>
BeanFactory有containsBean、getBean、isSingleton、getType、getAliases等方法。
ApplicationContext是BeanFactory的子接口，它增强了BeanFactory的功能，比如：提供国际化的消息访问、资源访问(读文件)、bean相关的事件控制、在web环境中可以实例化。
BeanFactory是延迟加载，ApplicationContext是创建Ioc容器就对bean进行初始化。
7、 DI依赖注入
1. 应用程序依赖spring注入所需要的对象
IOC和DI是对同一种事情的不同描述
2.setter注入： 在配置文件中将接口的实现配置为bean在应用程序中注入bean
例如：
在配置文件中
在应用程序中
Public DBDAO dao ;
Public void setDao(DBDAO dao){
This.dao = dao;
}
3.构造器注入
4.lookup方法注入
5.ref 表示参照其它的bean
在参照的过程中一定要注意死循环
6.自动装配-----------〉no
自动装配根据名字来匹配相应的bean 尽量不要去自动装配
7. bean的作用域：
singleton 单例
prototype 非单例
使用spring的webApplicationContext,则可以使用request,session和globalSession
8.DI的优点：
1.程序被动等待，强化面向接口编成
2.切断了对象或组件之间的联系，使程序的结构更加松散，运行和维护更加简单
8、 Aop面向切面编程
Aop中最重要的三个概念是切入点、切面，通知。
1.AOP面向切面编程
切面：代表我们所关注的一系列的共同的功能点(模块之间的共同的功能点)
面向切面编程提供了另外一种角度来思考程序的结构，弥补了面向对象编程的不足。
2.AOP的好处：
灵活的实现功能
使各个模块之间不耦合
3.AOP 的概念
1.切面 ：我们所关注的功能点
2.连接点 ：事件的触发点(方法的执行)
3.通知 ：连接点触发时执行的动作(方法)
4.切入点 ：一系列的连接点的集合 (连接点的模块化)
5.引入 ：扩展的功能
6.目标对象 ：包含连接点的对象
7.aop代理 ：实现机制
8.织入 ：把advice和目标对象连接起来
4.AOP的事件机制
1.通过切面找出一系列共同的功能点
2.找到目标对象(在标准的spring 中 接口的实现类为target)
3.找到切入点
4.确定连接点
5.通知spring AOP，查询xml文件，通过代理找到advice。
6.由aop代理来实现动态织入
5. AspectJ
5.1.在xml中配置比较烦琐
所有的入口必须从一个代理(ProxyFactoryBean)开始
expression="execution(* com.javakc.aop.MyTarget.t*())"/>
5.3.使用注解的方法相对简单
@AspectJ的基本语法
1.@Aspect声明一个切面，将一系列的共同的功能定义成一个切面
直接在类上定义@Aspect
2.@Pointcut声明切入点
2.1、用一个专门的类来定义pointcut，类中的方法名就是该pointcut的名字
2.2、可以使用匿名的pointcut
2.3、执行切点的几种方法
2.3.1 execute(public * 包结构.*.*.(..)) 可以指定到具体的方法
2.3.2 within 指定到包，不能指定到类
within("com.javakc.spring..*")
2.3.3 this 指定到实现接口的所有的实现类
2.3.4 target 指定具体的实现类
5.4.advice的五种类型的示例
客户端必须从接口走才能得到监控，实现想要追加的功能
5.4.1.@AfterReturning(pointcut="" returning="retVal")
追加的方法的参数名字一定要与retrning的名字相同
在注解@AfterReturning中必须加上pointcut和returning两个参数
pointcut指所要监控的目标对象的方法
得到目标对象的方法的返回值，来作为参数，进行下一步的处理,参数没有顺序，按参数的名字进行匹配
完成追加的功能
1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
(1).@AfterReturning("com.javakc.spring.schemaaop.TestPointcut.t4()")
(2).
2.直接引用匿名的pointcut
(1).@AfterReturning("execution(
* com.javakc.spring.schemaaop.Api.test4())")
(2).@AfterReturning(pointcut=
"com.javakc.spring.schemaaop.TestPointcut.t4() &&
args(str)", returning="retVal")
@AfterReturning (pointcut="com.javakc.spring.schemaaop.TestPointcut.t4() && args(str)",returning="retVal")
public void testAfterReturning(String str,Object retVal){
System.out.println("afterReturning1=>"+retVal+"=>"+str);
}
5.4.2.@Aronud
注解@Around环绕追加功能;
在执行目标对象的方法的前、后追加功能;
必须有参数;第一个参数的类型必须为ProceedingJoinPoint;
通过ProceedingJoinPoint的实例的proceed来调用所监控的
目标对象的方法
1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
(1).@Around("com.javakc.spring.schemaaop.TestPointcut.t1()")
(2).@Around("com.javakc.spring.schemaaop.TestPointcut.t2()
&& args(str)")
2.直接引用匿名的pointcut
(1).@Around("execution(
* com.javakc.spring.schemaaop.Api.test1())")
(2).@Around("execution(
* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)")
// @Around("com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)")
@Around("execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)")
public void testAround(ProceedingJoinPoint prj,String str) throws Throwable{
System.out.println("around1==========before1pointcut==>"+str)
Object obj = prj.proceed();
System.out.println("around1==========after1pointcut==>"+str);
}
5.4.3.@Before
注解@Before在执行目标对象的方法前追加相应的功能
1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
(1).@Before("com.javakc.spring.schemaaop.TestPointcut.t1()")
(2).@Before("com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)")
注意args后的名称与参数名相同
2.直接引用匿名的pointcut
(1).@Before("execution(* com.javakc.spring.schemaaop.Api.test1())")
(2).@Before("execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)")
注意args后的名称与参数名相同
// @Before("com.javakc.spring.schemaaop.TestPointcut.t2() && args(str)")
@Before("execution(* com.javakc.spring.schemaaop.Api.test2(..)) && args(str)")
public void testBeforeParam(String str){
System.out.println("before1=param=>"+str);
}
5.4.4.@After
注解@After在执行目标对象的方法后追加相应的功能
1 定义一个pointcut，通过方法名来作为pointcut的名称来引用
(1).@After("com.javakc.spring.schemaaop.TestPointcut.t1()")
2.直接引用匿名的pointcut
(1).@After("execution(* com.javakc.spring.schemaaop.Api.test1())")
@After("com.javakc.spring.schemaaop.TestPointcut.t1()")
public void testAfter(){
System.out.println("after1== >pointcut");
}
5.4.5.@AfterThorwing
9、 描述一下spring中BeanFactory和ApplicationContext的差别
BeanFactory是一个Interface,这是Spring的核心。它仅仅只是提供的一些基本功能。ApplicaionContext 也是一个interface,这是从BeanFactory继承过来的所以它具备了BeanFactory的所有功能。但它也从其它的类或interface得到了一些特性。比如提供国际化的消息访问，资源访问，事件传播。
但其主要区别在于BeanFactory是延迟加载,如果Bean的某一个属性没有注入，BeanFactory加载后，直至第一次使用getBean方法调用此Bean时才会抛出异常;而ApplicationContext则在初始化自身时检验，这样有利于检查所依赖属性是否注入;所以通常情况下我们选择使用ApplicationContext.
代码示例：
BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource("beans.xml"));
ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
10、 谈谈spring对DAO的支持
Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术。
简化 DAO 组件的开发。 Spring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，用来简化代码开发。
IoC 容器的使用，提供了 DAO 组件与业务逻辑组件之间的解耦。所有的 DAO 组件，都由容器负责注入到业务逻辑组件中，其业务组件无须关心 DAO 组件的实现。
面向接口编程及 DAO 模式的使用，提高了系统组件之间的解耦，降低了系统重构的成本。
方便的事务管理: Spring的声明式事务管理力度是方法级。
异常包装:Spring能够包装JDBC异常，把它们从CheckedException变为RuntimeException; 开发者可选择在恰当的层处理数据中不可恢复的异常，从而避免烦琐的 catch/throw 及异常声明。
11、 谈谈spring对hibernate的支持
在所有的 ORM 框架中， Sping 对 Hibernate 的支持最好。如 SessionFactory 的注入、HibernateTemplate 的简化操作及 DAO 支持等。另外， Spring 还提供了统一的异常体系及声明式事务管理等。
一旦 Hibernate 处于 Spring 的管理下， Hibernate 所需要的基础资源，都由 Spring 提供注入。 Hibernate 创建 SessionFactory 必需的 DataSource ，执行持久化必需的 Session 及持久层访问必需的事务控制等，这些原本必须通过代码控制的逻辑，都将由Spring 接管:DataSource, SessionFactory, TransactionManager等，都将作为 Spring 容器中的 bean。将这些bean 放在配置文件中管理。
1、通用的资源管理: Spring 的 ApplicationContext 能管理 SessionFactory，使得配置值很容易被管理和修改，无须使用Hibernate 的配置文件。详细配置如下：
class="org.apache.commons.dbcp.BasicDataSource">
oracle.jdbc.driver.OracleDriver
jdbc:oracle:thin:@localhost:1521:orcl
javakc2
javakc2
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
com/javakc/spring/h3/UserModel.hbm.xml
hibernate.dialect=org.hibernate.dialect.OracleDialect
如果需要使用容器管理的数据源，则无须提供数据驱动等信息，只需要提供数据源的JNDI 即可。对上文的SessionFactory只需将dataSource的配置替换成 JNDI 数据源，并将原有的 myDataSource Bean 替换成如下所示:
class="org.springframework.jndi.JndiObjectFactoryBean">
java:comp/env/jdbc/myds
2、有效的 Session 管理: Dao类继承HibernateDaoSurport后，Spring 提供了 HibernateTemplate，用于持久层访问，该模板类无须显示打开 Session及关闭 Session。它只要获得 SessionFactory 的引用，将可以智能打开 Session，并在持久化访问结束后关闭 Session ，程序开发只需完成持久层逻辑，通用的操作则由HibernateTemplate 完成。
3、统一的事务管理。无论是编程式事务，还是声明式事务， Spring 都提供一致的编程模型，无须烦琐的开始事务、显式提交及回滚。
建议使用声明式事务管理，Spring 的声明式事务以 Spring 的 AOP 为基础。可将事务管理逻辑与代码分离。代码中无须实现任何事务逻辑，程序开发者可以更专注于业务逻辑的实现。声明式事务不与任何事务策略藕合，采用声明式事务可以方便地在全局事务和局部事务之间切换。
Spring声明性事务有两种配置方法，一种是xml配置：
另一种是通过注解，在需要添加事务的类上注明 @Transactional
Spring2.0之前事务的写法
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
abstract="true">
PROPAGATION_REQUIRED,readOnly
PROPAGATION_REQUIRED
12、 谈谈Spring对事务的支持
1、声明式事务管理：
1.流程：由客户端访问----aop监控----调用advice来追加事务
2.做法：
2.1 在配置文件的头中引入xmlns：tx 和schema的文件
2.2
2.3 注入数据源
2.4 由spring实现的事务管理，但需要注入数据源
2.5 事务监控所有的方法(事务加强)
2.6 定义切入点
expression="execution(* com.javakc.spring.schemaaop.api.*.*(..))"/>
2、使用注解实现事务管理：
1.注解@Transcational
(可以在类上，也可以在方法上)
2.在配置文件中同样需要注入dataSource和spring的事务管理
3.使用注解的方法来追加事务 注解驱动
如何在Spring中使用Hibernate的事务：
如何在Spring中使用JTA的事务：
13、
事务
1、 ACID
(1)原子性(A)：一系列的操作具有不可分割性，要么成功，要么失败
(2)一致性 ：操作的前后满足同样的规则，保持平衡。
(3)隔离性 ：在事务运行的过程中。事务内的数据对外的可见性和可操作性(必需由数据库的支持)
(4)稳定性 ：保证数据在事务的操作的过程中不会遭到破坏，而且是永久性存储的
2、 事务模型
(1)经典事务模型又叫平面事务模型(JDBC) 事务不允许嵌套
(2)嵌套事务模型
3、 事务的两种方式
(1)声明式
在配置文件中设置以下6项
(1).required
如果客户端没有事务 在bean中新起一个事务
如果客户端有事务bean 中就加进去
(2)、 requiresNew
不管客户端有没有事务服务器段都新起一个事务
如果客户端有事务就将事务挂起
(3)、supports
如果客户端没有事务服务端也没有事务
如果客户端有事务服务端就加一个事务
(4)、mandatcry
如果客户端没有事务服务端就会报错
如果客户端有事务服务端就加事务
(5)、notSupported
不管客户端有没有事务服务端都没有事务
如果客户端有事务服务端就挂起
(6)、never
不管客户端有没有事务服务端都没有事务
如果客户端有事务就报错
(2)编程式事务
Javax.transaction.UserTranscation
JTA 事务可以精确到事务的开始和结束
4、 事务的隔离性
Read-uncommited
读取未提交的数据(基本上没有锁)脏读，存在不当读取的问题。
Read-commited
读取已提交的数据(行级锁)
无法读取已经写入，但没有被提交的数据。
Repeatable_read
读取的数据不允许修改或删除
不可重复读(行级锁+不允许修改/删除)
Serializable
幻影读(表级锁)
struts
开发流程
1、创建表单
2、从表单中获得输入
3、处理输入(业务逻辑)
4、根据动态输入改变输入流
要完成上述四步，我们需要创建
1、一个ActionForm
2、一个action
3、一个配置文件struts-config.xml
4、创建页面
创建ActionForm
1、写一个类继承ActionForm
2、私有的属性
3、相应的get、set方法
4、重写tostring、equals、hashcode三个方法
创建action
1、写一个类继承Action
2、实现一个公有的方法(回调方法)
public ActionForward execute(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
{
//1.收集参数
MyActionForm myForm = (MyActionForm)form;
//2.组织参数
//3.调用逻辑层
boolean flag = true;
//4.根据返回值来跳转到相应的页面
ActionForward af = new ActionForward();
if(flag){
af = mapping.findForward("1");
}else{
af = mapping.findForward("2");
}
return af;
}
配置struts-config.xml文件
1.
2.
name="myActionForm"
type="全路径.MyAction"
scope="session"
input="错误返回的页面">
步骤:
1.创建一个空的web应用
2.将struts的包放到lib文件夹下
3.将.tld文件文件和struts-config.xml、web.xml放到WEB-INF的跟目录下
4.配置struts-config.xml文件和web.xml文件
5.在页面引入tag文件uri
STRUTS运行机制
1、界面点击产生请求
2、容器接到请求
3、匹配web.xml文件中的*.do来调用ActionServlet
4、ActionServlet的处理
4.1 读struts-congfig.xml文件形成ActionMapping
4.2 通过path 来匹配Action类，通过Action的name属性来匹配ActionForm类
4.3 通过反射机制来给Form添数据
4.4 由ActionServlet转调Action的execute方法
4.5 得到execute方法的返回值，跳转页面
4.5.1 RequestDispatcher
4.5.2 response.sendRedirect("list.jsp");
【Java代码的基本知识】相关文章：