大爆炸

Posted 2020-09-17

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

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


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