大爆炸

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了大爆炸相关的知识,希望对你有一定的参考价值。


工欲善其事必先利其器,电脑不行的找我装系统,加内存方便高效 ,加固态硬盘,终极方法,换电脑。

***********
有同学发现重要的一些知识点大爆炸没提到的,
将需要记录的知识点发给我我来更新大爆炸版本。谢谢大家 ^_^


**************************更新日志**********************************
更新了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实例的细节,
                  所有细节就交于工厂处理,而调用者只需要下发指令即可
        

以上是关于大爆炸的主要内容,如果未能解决你的问题,请参考以下文章

2014年 生活大爆炸版石头剪刀布

UWP中实现大爆炸效果

生活大爆炸 百度网盘 下载 1-11季

UWP中实现大爆炸效果

UWP中实现大爆炸效果

生活大爆炸版石头剪刀布