标签：后缀名 视图 limit 关键词 安全控制 固态硬盘 作用 rup 方便
工欲善其事必先利其器，电脑不行的找我装系统，加内存方便高效 ,加固态硬盘，终极方法，换电脑。
***********
有同学发现重要的一些知识点大爆炸没提到的，
将需要记录的知识点发给我我来更新大爆炸版本。谢谢大家 ^_^
**************************更新日志**********************************
更新了Struts标签库
更新了AOP的一些配置信息
更新了设计模式的一些概念
struts中如何获取request
3.18 action类的作用
3.23 更新了hibernate搭建步骤
********************************************************************
struts
1. struts2配置文件是(struts.xml),此配置文件被核心控制器默认加载时名字必须为struts.xml，必须在
src 路径下
2. struts2核心控制器是(FilterDispatcher 旧版本，StrutsPrepareAndExecuteFilter 新版本)
3. struts2配置文件中Action标签的class属性值是(action类的全名，也就是路径)
name属性的值是(代表Action的名称 从前台访问时的路径组成部分)
4. struts2配置文件中result标签的属性 name 的属性值与 action 类方法返回的字符串匹配。
type 的属性值默认是(dispatcher 跳转页面)重定向的值是(redirect)
5. struts2 框架的搭建步骤：
1. 导入jar包 到 lib目录
2. 在 web.xml 内 增加 struts 核心控制器 配置
3. 将 struts.xml 放在 src目录下
4. 新建Action类 需要继承 ActionSupport
方法修饰符必须是 public 返回值类型为 String 没有参数
5. 配置struts.xml 中的 action 标签以及 result 标签
6. 在页面通过 struts.xml中配置的 Action名称 对 Action进行访问
访问路径为:<%=path%>/action名称!方法名.action
6.struts2 的 运行原理
1. tomcat 启动加载Web.xml ，核心控制器FilterDispatcher
（新版：StrutsPrepareAndExecuteFilter） 加载并解析 struts.xml
2. 客户端 发出请求到 Action ，FilterDispatcher 根据后缀名拦截
3. FilterDispatcher 根据 struts.xml配置文件信息 找到 指定的 Action方法
4. 执行相关的业务逻辑后 返回字符串
5. 根据返回字符串，在 struts.xml的<result>的name属性的值，进行匹配跳转到指定的
jsp或重定向到其他Action
7. 精确匹配和 模糊匹配的 区别
1. 精确匹配
struts.xml中 Action 配置 method属属性的值 是Action类中的某一个方法
前台访问时 Action名称.action
缺点: 配置繁琐 action类中的每一个方法 都需要配置一个 <Action> 标签
优点: 分工明确 一个配置发生错误 不会影响其他Action的运行
2. 模糊匹配
struts.xml中，Action配置name值时通过通配符*配置请求的格式
class 和 method通过 {数字} 的方式 引用 name中通配符信息
前台访问时 按Action中定义的规则.action 去访问
缺点: 如果配置错误 所有的 Action 都不能使用
优点: 配置文件中 需要配置的 <action> 会变少
8. struts2 简述
struts2 是一个MVC框架 基于WebWork 发展而来.属于控制层框架。
负责jsp页面和java代码之间的值的传递和跳转
核心控制器是FilterDispatcher 2.1.2 版本前含2.12
从2.1.3版本开始用 StrutsPrepareAndExecuteFilter代替了。。
9.Struts2中action要继承哪个类(ActionSupport)
10.Struts2 标签
注意：一定不要忘记导入标签库
<%@ taglib prefix="s" uri="/struts-tags" %>
取值使用 # 例：#page 与 c 标签的${page}相同
1)迭代标签(<s:iterator>)
2)判断标签(<s:if>)
3)取值标签(<s:property>)
4)格式化日期标签(<s:date>)
5)输出标签(<s:property>)
6)赋值标签(<s:set>)
11. Struts2自定义拦截器的三种实现方式
1) 实现 接口 Interceptor
2) 继承 抽象类 AbstractInterceptor 重写intercept方法
3) 继承 MethodFilterInterceptor类
允许拦截器通过执行的方法：
invocation.invoke();
12.Struts2中action中如何获得request
HttpServletRequest request = ServletActionContext.getRequest();
13.action类的作用
url ：action负责url的调换
传值：action负责获取前台的值 ，以及将值传到前台页面（${javabeanName.javabean属性}）
传值：属性驱动：
1.需要私有化属性
2.生成get set方法
3.给实体类赋值，需要级联操作赋值（javabeanName.javabean 属性）
模型驱动：
1.首先需要实现 ModelDriven<Hero> ，需要将定义泛型为Javabean（实体类）
2.需要重写 getModel 方法 此方法返回值为 泛型 实体类
3.私有化并实例化你的实体类
14.MVC设计模式
M：model 模型层
V：view 视图层
C：control 控制层
是一种将模型层、视图层与控制层的业务进行分离的设计模式，提高了代码的可读性与重用性。
分离视图层和业务逻辑层也使得WEB应用更易于维护和修改。
hibernate
1．Mysql的默认端口号是(3306)
默认用户名 root
2．Mysql中的分页关键词是(limit)
select * from t_table limit index,count
（index 查询的开始下标 ，count 查询的条数）
3．Hibernate两大核心配置文件是(hibernate.cfg.xml)核心控制文件和(*.hbm.xml)实体类映射文件
4．Hibernate中表与表之间关联关系有
(一对一 one-to-one)、
(一对多 one-to-many)、
(多对一 many-to-one)、
(多对多 many-to-many)、
5．Hibernate中的五大核心类和接口
Configuration(类) ：
加载配置文件hibernate.cfg.xml文件中的配置信息，从而得到：
1).hibernate的底层信息：
数据库连接，jdbc驱动，方言（dialect），用户名 ，密码
2).hibernate的映射文件（*.hbm.xml）
SessionFactory(接口)：
通过configuration创建的sessionFactory，
可以用来获得session openSession();
sessionFactory是线程安全的，
里面保存了数据的配置信息和映射关系
Session(接口)：
不是线程安全的，相当于jdbc中connection，我们可以使用session来操作数据库
负责保存、更新、删除、加载和查询对象，是一个非线程安全的，避免多个线程共
享一个session，是轻量级，一级缓存。
Transaction(接口)：
session.beginTransaction(); //由于Hibernate增删改需要使用事务所以这里要开启事务
session.getTransaction().commit(); //提交
我们一般使用Transaction来进行事务的管理commit（提交）rollback（回滚）
Query(接口)：
我们一般用来进行数据的查询操作
6．Hibernate中两种占位符是(?)和(:变量名)
6.1 ？的赋值方式： query对象.setParameter(index,value)
6.2 :变量名赋值方式： query对象.setParameter("变量名",value)
7．Hibernate中query对象的常用方法
query对象.executeUpdate() 方法对数据进行修改或者删除
query对象.uniqueResult() 方法返回单条记录，获取唯一结果集
query对象.setFirstResult() 方法设置结果集开始位置，查询开始条数
query对象.setMaxResults() 方法设置每页查询条数
query对象.list() 方法返回查询结果集
8. Hibernate中session 对象的常用方法有
1.find(String queryString) 查询返回list结果集
根据HQL查询字符串来返回实例集合find方法在执行时会先查找缓存,如果缓存找不到再查
找数据库,如果再找不到就会返回null。
2.save(Object entity) 添加 保存新的实例
3.saveOrUpdate(); 添加或修改 有id是修改 没id 是更新
4.delete(Object entity); 删除 删除指定的持久化实例
5.update(Object entity); 修改 更新实例的状态 实例必须为持久化状态
6.get(Class entityClass,Serializable id)根据ID查询 根据主键加载特定持久化实例
7.load();根据唯一标识获得 对象 延迟加载
9. get 和 load 的区别
1).load是延迟加载（懒加载，按需加载）调用load方法后不会立即发送SQL语句，
当访问实体属性的时候才会去发送SQL语句，如果访问的实体不存在，
则返回ObjectNotFoundException（对象不存在异常）
2).get 是立即加载，当调用get方法后立即发送sql语句，
当访问的实体不存在的时候，则返回null
get(Class entityClass,Serializable id)根据主键加载特定持久化实例
在程序中一般先用 Assert.isTrue断言id是否大于0，若大于0继续执行，若查到数据
则返回实例，否则返回空不同于load，load若有数据则返回实例，
否则报出ObjectNotFoundEcception异常，相比来说get效率高些
注意：
load支持懒加载通过lazy=“true”设置，
如果lazy=“false”，则load不再进行懒加载
默认情况下lazy=“true”
10. hibernate配置文件设置方言的关键字(dialect)
<!-- 数据库方言***记过-->
<!-- oracle 方言org.hibernate.dialect.Oracle9Dialect -->
<!-- mysql 方言org.hibernate.dialect.MySQLDialect -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
11．Hibernate中两种事务类型分别是(jdbc事务)、(JTA事务)
12. 五个hibernate主键生成策略并分别描述
Increment:先查询出最大id，在此基础上加1；hibernate框架会自动处理
Sequence(Orade) :oracle 数据库会自动处理
Assigned:人工指派（重复插入数据时会违反数据唯一性）
native(数据库本地生成策略，适用多个数据库)
适用于mysql.oracle,sqlserver,
如果是orade数据库则默认使用的序列名为hibernate-sequence
uuid:生成一个32位，不会重复的主键，可以达到真正的跨数据库
（通常来说对应的应该是string数据类型）
foreign：通常在一对一主键的时候使用，基于外键的主键生成策略
===========================================================================================
13. jdbc和hibernate的区别
hibernate是jdbc轻量级的封装,hibernate基于jdbc
jdbc
jdbc是纯手工的(sql语句，对于结果集的解析)
执行效率高于hibernate，
使用的sql语句，
jdbc是直接操作数据库中的表 select * from 表名
hibernate
hibernate是一个对JDBC进行轻量级封装的持久层框架
hibernate是全自动的(将常用方法进行了封装，
不用手动进行结果集的解析)
hibernate是跨数据库的，
hibernate的开发效率高于jdbc，
hibernate使用的hql语句，
但是在最后操作数据库是hql语句会转化成sql语句去执行，
hibernate操作的是对象 from 类名
14. hibernate的三种状态
transient[‘tr?nz??nt](临时状态)：
在创建对象即在new之后，在save之前的状态：
session中和数据库中都不存在该数据
persistent[p?‘s?st(?)nt](持久化状态):
在save之后，session关闭之前，
session中和数据库中都存在对应的数据
detached[d?‘t?t?t](托管状态/游离状态):
session关闭之后，session不存在，
数据中有对应的数据
15. hibernate 运行原理
通过configuration加载了hibernate.cfg.xml文件，
加载文件后得到sessionFactory，（sessionFactory是线程安全的）
然后通过sessionFactory得到session（session是线程不安全的，相当于jdbc中connection）
通过session操作对象，来操作数据库，最后通过Transaction来进行事务的控制
16.hibernate所使用的语句是hql语句，它是将操作的表改为映射的实体类来操作，hql语句最终会被解析
为sql语句 。
17.hibernate(冬眠)的概述
hibernate是一个对JDBC进行轻量级封装的持久层框架
hibernate是全自动的(将常用方法进行了封装，不用手动进行结果集的解析)
hibernate是跨数据库的，
hibernate的开发效率高于jdbc，
hibernate使用的hql语句，
但是在最后操作数据库是hql语句会转化成sql语句去执行，
hibernate操作的是对象 from 实体类名
18.hibernate 的搭建步骤：
1.导入支持框架的jar包
2.配置xml配置文件
2.1 hibernate.cfg.xml 核心控制文件
2.2 javaBean.hbm.xml 实体类映射文件（记得将映射文件引入核心控制器文件）
2.2.1 javabean.hbm.xml 一般与实体类放一起
3.创建实体类
Spring（春天）
1.spring概述
spring 就相当于一个粘合剂。
有两个核心，分别是IOC/DI(控制反转/依赖注入)
AOP(面向切面编程/面向方面编程)完全面向接口设计，
主要用来进行bean实例的创建注入（IOC/DI），
以及进行事务的管理（AOP）
2、spring中自动注入的两种方式分别是(byName)和(byType)
3、ioc的两种注入方式(属性注入)和(构造方法注入)
4、Spring中的容器是(ApplicationContext)和(BeanFactory)
5、spring中通过(scope)属性设置属性值为(singleton)来设置单例，
设置属性值为(prototype)来设置多例（原型）。
6、bean注入时，引用数据类型通过(ref)属性或标签赋值
7、aop通过：read-only=true 配置只读事务
rollback-for 配置回滚策略
propagation 配置传播特性
transaction-manager 配置指定事务管理器
pointcut 定义AOP的切面
定义切入点的表达式为：execution(* com.jk.*.service.*.*(..))
表示：com.jk.任意包.service.任意类.任意方法(..任意参数)
execution(* )是固定格式
8. spring 控制事务的aop的切点应该控制在 (service)层
9. spring 配置文件是(applicationContext.xml)
10.阐述事务四大特性
1).原子性
原子性是指事物是一个不可分割的工作单位,
事务中的操作要么都不发生，要么都发生
2).一致性
事务必须使数据库从一个一致性状态变换到另一个一致性状态（数据不被破环）
3).隔离性
事务的隔离性是指一个事务的执行不能被其他事务干扰
4).持久性
持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的
11.AOP的理解：
1.AOP是OOP（面向对象编程）的延续，是Aspect Oriented Programming的缩写，意思是面向方面编程或者面向切面编程。
2.AOP主要应用于日志记录，性能统计，安全控制，事务处理等方面。它的主要意图就要将日志记录，性能统计，安全控制等等代码从核心代码中清楚的划分出来。
3.AOP代理可以通过jdk动态代理实现，也可以通过cglib实现，默认是通过jdk动态代理实现的。jdk动态代理需要接口的支持，如果没有接口只有类，则使用cglib来实现。
12.代理的理解：
代理分为静态代理和动态代理
静态代理：
一个接口对应一个实现类和一个代理实现类，让代理实现类去做实现类想做的事
动态代理：
一个接口只有一个实现类，没有代理实现类，在项目运行时，动态创建一个代理类来代替实现类去做某事
13.ApplicationContext和BeanFactory的区别
BeanFactroy采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调用getBean())，才对该
Bean进行加载实例化，这样，我们就不能发现一些存在的Spring的配置问题。
而ApplicationContext则相反，它是在容器启动时，一次性创建了所有的单实列Bean。这样，在容器启动时，
我们就可以发现Spring中存在的配置错误。因此ApplicationContext的初始化时间比BeanFactory稍长些，但访问bean的时候就更快些。
14.IOC的理解
IOC的作用：产生对象实例，所以它是基于工厂设计模式的
Spring IOC的注入
通过属性进行注入，通过构造函数进行注入，
注入对象数组 注入List集合
注入Map集合 注入Properties类型
Spring IOC 自动绑定模式：
可以设置autowire按以下方式进行绑定按byType只要类型一致会自动寻找，按byName自动按属性名称进
行自动查找匹配.
=================================================================================================
SSH 框架
1. SSH框架的搭建步骤 ：
1.创建web项目
2.导入ssh相应的jar包
3.创建包结构，面向接口
3.导入配置
3.1 在web.xml中添加Struts2的核心控制器 和 spring的监听
3.2 将struts.xml、hibernate.cfg.xml、applicationContext.xml配置文件放在src下
3.2.1 因为applicationContext.xml会加载解析hibernate.cfg.xml所以需要将
hibernate.cfg.xml文件配置完整
3.3 将javabean.hbm.xml映射文件及相应的实体类配置好
4.action类需要继承ActionSupport，action类中的方法必须是public修饰，返回值类型必须
是 String ，没有参数
5.service接口注入到spring中由spring管理，此时action中需要私有化此service属性并生成get
set 方法。
6.dao 接口注入到spring中由spring管理，此时service需要私有化此dao属性并生成get、set方法
dao层需继承HibernateDaoSupport
==================================
1):首先在web.xml中通过contextLoaderListener来融入spring
并加载spring相关配置文件
2)：同样配置struts2前端总控制器filterDispatcher来过滤相关的请求
并加载struts.xml
3):action继承ActionSupport 然后引入struts-spring-plugin.jar包
并在配置文件中注入service 提供get set 方法
4):通过spring配置sessionFactory 读取hibernate.cfg.xml 数据库信息,这时hibernate.cfg.xml
必须配置完全
5)：dao层继承HibernateDaoSupport 在spring配置文件中dao注入sessionFactory
6): 在applicationContext.xml中通过byName自动注入service 和dao
==============================================================================================
2. 文件上传注意事项
1) 表单中必须添加属性 enctype="multipart/form-data"
2) action 中接收 文件的属性有两个
1: File 类型的 属性 接收文件实体
2: String类型的文件名 属性 接收 文件名信息
注意 :接收文件名的属性名称 是 接收File实体的属性名称+FileName ;
3) 数据库中存储的 是上传后的路径
4) 前台回显时 是虚拟路径+数据库存储的文件路径
5) 如果修改时不修改图片，只需要在action中判断file属性是否为空
=================================================================================================
设计模式：
-----------------------------------------单例模式开始------------------------------------------------
Java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、
饿汉式单例、登记式单例。
单例模式有以下特点：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、
缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管
理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输
出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时
被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。
//懒汉式单例类.在第一次调用的时候实例化自己
public class Singleton {
private Singleton() {}
private static Singleton single=null;
//静态工厂方法
public static Singleton getInstance() {
if (single == null) {
single = new Singleton();
}
return single;
}
//饿汉式单例类.在类初始化时，已经自行实例化
public class Singleton1 {
private Singleton1() {}
private static final Singleton1 single = new Singleton1();
//静态工厂方法
public static Singleton1 getInstance() {
return single;
}
}
饿汉式和懒汉式区别
从名字上来说，饿汉和懒汉，
饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，
而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。
另外从以下两点再区分以下这两种方式：
1、线程安全：
饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，
懒汉式本身是非线程安全的，为了实现线程安全有几种写法，分别是上面的1、2、3，这三种实现在资源加
载和性能方面有些区别。
-----------------------------------------单例模式结束------------------------------------------------
代理模式：
代理分为静态代理和动态代理
静态代理：
一个接口对应一个实现类和一个代理实现类，让代理实现类去做实现类想做的事
动态代理：
一个接口只有一个实现类，没有代理实现类，在项目运行时，动态创建一个代理类来代替
实现类去做某事
代理模式中的角色
* 1. 抽象角色 (接口)
* 2. 真实角色 真正的执行方法所在的类
* 3. 代理角色 代理真实角色的类
阐述动态代理模式
答：Spring AOP 基于代理设计模式（基于jdk 的动态代理）
所谓代理设计模式：在代理模式中有个接口，接口中有个代理实现，要用代理实现去代表真实实现
工厂设计模式：
1. 简单工厂模式
2. 工厂方法模式
3. 抽象工厂模式
好处: 不用考虑实例化对象的细节
spring的 ioc (控制反转/依赖注入)就是使用工厂设计模式实现的
考试题：阐述工厂设计模式
答： 使用工程设计模式可以无需关注创建bean实例的细节，
所有细节就交于工厂处理，而调用者只需要下发指令即可
标签：后缀名 视图 limit 关键词 安全控制 固态硬盘 作用 rup 方便
原文地址：http://www.cnblogs.com/wjh-93-3-1/p/6842744.html
