今天总结的一些Java的一些基础知识

1.Java导出excel表的HssfWorkBook

.一级缓存（sqlSession)

    一级缓存是SqlSession自带的。SqlSession对象被创建，一级缓存就存在了。
    如果SqlSession对象关闭或调用清理方法，会导致缓存失效。
    缓存底层实现就是通过HashMap实现的。
    一级缓存介质——内存

 

3.二级缓存(cacheEnabled)

    二级缓存介质——内存，硬盘
    二级缓存SqlSessionFactory进行管理的。SqlSessionFactory对象是进程级别的。可以被多个SqlSession所共享。

跟Web应用中application对象作用范围类似。

    MyBatis框架自带了二级缓存，是通过HashMap实现的。
        二级缓存使用，需要在主文件中进行配置：
            ①启用二级缓存

    ②在XxxMapper.xml文件中配置二级缓存策略

    eviction：缓存策略
        FIFO：First In First Out
        LRU：Least Recently Used
    flushInterval：缓存刷新时间间隔，时间是毫秒，检查是否存在过期对象
    size：缓存中存储的对象个数
    readOnly：是否只读

    ③对于MyBatis自带的二级缓存，实体类可以不用实现可序列化接口。
        如果使用的是EhCahce缓存组件，有时会将数据缓存到硬盘上，需要可序列化支持的。必须实现java.io.Serializable

 

 

Hibernate之一级缓存和二级缓存

1：Hibernate的一级缓存：

1.1：使用一级缓存的目的是为了减少对数据库的访问次数，从而提升hibernate的执行效率；（当执行一次查询操作的时候，执行第二次查询操作，先检查缓存中是否有数据，如果有数据就不查询数据库，直接从缓存中获取数据）；

1.2：Hibernate中的一级缓存，也叫做session的缓存，它可以在session范围内减少数据库的访问次数，只在session范围内有效，session关闭，一级缓存失败；

1.3：一级缓存的特点，只在session范围有效，作用时间短，效果不是特别明显，在短时间内多次操作数据库，效果比较明显。

1.4：当调用session的save/saveOrUpdate/get/load/list/iterator方法的时候，都会把对象放入session缓存中；

1.5：session的缓存是由hibernate维护的，用户不能操作缓存内容；如果想操作缓存内容，必须通过hibernate提供的evict/clear方法操作

1.6：缓存相关的方法（在什么情况下使用上面方法呢？批量操作情况下使用，如Session.flush();先与数据库同步，Session.clear();再清空一级缓存内容）：

session.flush();让一级缓存与数据库同步；

session.evict();清空一级缓存中指定的对象；

session.clear();清空一级缓存中所有的对象；

1.7：面试题，不同的session是否会共享缓存数据？

  答：不会哦~~~

1.8：list和iterator的区别？

（1）list查询：

答： 一次性把所有的记录都查询出来了；会放入缓存，不会从缓存中取数据；

（2）iterate（N+1次查询）：

答： N表示所有的记录总数，即会发送一条语句查询所有的记录的主键，这是第一条查询语句，再根据每一个主键取数据库查询，这是根据第一次查询的条数进行N次查询操作；会放入缓存，也会从缓存中取出数据；

2：Hibernate的懒加载：

2.1：懒加载概念：当用到数据的时候才向数据库查询，这就是hibernate的懒加载特性。

使用懒加载的目的，是提高程序执行效率。

2.2：查询操作：get()方法/load()方法

（1）get()方法，及时加载。及时查询操作；只要调用get方法立刻向数据库查询。

（2）load()方法，默认懒加载，即在使用数据的时候，才向数据库发送查询的sql语句。session关闭以后，不可以使用懒加载。

复制代码
#懒加载默认为true，即为懒加载，可以改为非懒加载。即lazy="false"
#lazy="false" 关闭懒加载
#lazy="true"使用懒加载
#lazy="extra"在真正使用数据的时候才向数据库发送查询的sql语句。集合属性懒加载的时候提升效率。如果调用集合的size()/isEmpty()方法只是统计，不真正查询数据。

......

复制代码

  2.3：懒加载异常：

Session关闭后，不能使用懒加载数据，如果session关闭后，使用懒加载数据报错如：
复制代码

org.hibernate.LazyInitializationException: could not initialize proxy - no Session
    at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:167)
    at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:215)
    at org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer.invoke(JavassistLazyInitializer.java:190)
    at com.bie.lesson05.Dept_$$_javassist_1.getDeptName(Dept_$$_javassist_1.java)
    at com.bie.lesson05.ManyToManyTest.lazyTest(ManyToManyTest.java:241)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
    at java.lang.reflect.Method.invoke(Unknown Source)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:86)
    at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:459)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:675)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192)

复制代码

如何解决session关闭后不能使用懒加载加载数据的问题：

方式一：可以先在关闭session之前使用一下数据，这样关闭以后就可以使用此数据了。如Dept.getDeptName()；

方式二（推荐）：强迫代理对象初始化操作：Hibernate.initialize(对象)；

方式三：关闭懒加载（lazy="false"）;

方式四（推荐）：在使用数据之后再关闭session；

 3：二级缓存：

    Hibernate提供的缓存

    有一级缓存、二级缓存。 目的是为了减少对数据库的访问次数，提升程序执行效率！

     

    一级缓存：

    基于Session的缓存，缓存内容只在当前session有效，session关闭，缓存内容失效！

    特点：

    作用范围较小！ 缓存的事件短。

    缓存效果不明显。

3.1：二级缓存概述：

二级缓存：

Hibernate提供了基于应用程序级别的缓存即为二级缓存，可以跨多个session，即不同的session都可以访问缓存数据。 这个缓存也叫二级缓存。

Hibernate提供的二级缓存有默认的实现，且是一种可插配的缓存框架！如果用户想用二级缓存，只需要在hibernate.cfg.xml中配置即可； 不想用，直接移除，不影响代码。

如果用户觉得hibernate提供的框架框架不好用，自己可以换其他的缓存框架或自己实现缓存框架都可以。

3.2:查看hibernate.properties配置文件，二级缓存如何配置？
复制代码

##########################

### Second-level Cache ###

##########################

#hibernate.cache.use_second_level_cache false【二级缓存默认不开启，需要手动开启】

#hibernate.cache.use_query_cache true      【开启查询缓存】

 
## choose a cache implementation 【二级缓存框架的实现】

 
#hibernate.cache.provider_class org.hibernate.cache.EhCacheProvider

#hibernate.cache.provider_class org.hibernate.cache.EmptyCacheProvider

hibernate.cache.provider_class org.hibernate.cache.HashtableCacheProvider 默认实现

#hibernate.cache.provider_class org.hibernate.cache.TreeCacheProvider

#hibernate.cache.provider_class org.hibernate.cache.OSCacheProvider

#hibernate.cache.provider_class org.hibernate.cache.SwarmCacheProvider

复制代码

3.3：二级缓存，使用步骤：

1) 开启二级缓存；

2)指定缓存框架；

3)指定那些类加入二级缓存；

4)测试；
复制代码

true

org.hibernate.cache.HashtableCacheProvider

true





        

复制代码

  3.4：缓存策略：

     放入二级缓存的对象，只读;
  非严格的读写
    读写； 放入二级缓存的对象可以读、写；
   (基于事务的策略)

 
Jsp的问题
二,九大内置对象到底是哪九大呢?

    内置对象名          类型
    request           HttpServletRequest
    response       HttpServletResponse
    config         ServletConfig
    application    ServletContext
    session        HttpSession
    exception      Throwable
    page           Object(this)
    out            JspWriter
    pageContext    PageContext

四大作用域
page域:    只能在当前jsp页面使用                (当前页面)
request域: 只能在同一个请求中使用               (转发)
session域: 只能在同一个会话(session对象)中使用  (私有的)
context域: 只能在同一个web应用中使用            (全局的)

===========================================

1.测试Java网站的并发量：JMeter 和 postMan
2.Java的地址相当于C的指针

===========================================

基本类型的变量如果是临时变量，只要定义了，就会分配内存空间，不管是否被赋值；如果是作为对象的属性出现，只要该对象不实例化，就不会分配内存空间。

一个完整的Java程序运行过程会涉及以下内存区域：
1、寄存器：JVM内部虚拟寄存器，存取速度非常快，程序不可控制。
2、 栈：保存局部变量的值，包括：
1）用来保存基本数据类型的值；
2）保存类的实例，即堆区对象的引用(指针)
3）也可以用来保存加载方法时的帧
3、堆：用来存放动态产生的数据，比如new出来的对象。注意创建出来的对象只包含属于各自的成员变量，并不包括成员方法。因为同一个类的对象拥有各自的成员变量，存储在各自的堆中，但是他们共享该类的方法，并不是每创建一个对象就把成员方法复制一次。

4、常量池：JVM为每个已加载的类型维护一个常量池，常量池就是这个类型用到的常量的一个有序集合。包括直接常量(基本类型，String)和对其他类型、方法、字段的符号引用(1)。池中的数据和数组一样通过索引访问。由于常量池包含了一个类型所有的对其他类型、方法、字段的符号引用，所以常量池在Java的动态链接中起了核心作用。常量池存在于堆中。

5、代码段：用来存放从硬盘上读取的源程序代码。
6、数据段：用来存放static定义的静态成员。

注意：
1.一个Java文件，只要有main入口方法，我们就认为这是一个Java程序，可以单独编译运行。
2.无论是普通类型的变量还是引用类型的变量(俗称实例)，都可以作为局部变量，他们都可以出现在栈中。只不过普通类型的变量在栈中直接保存它所对应的值，而引用类型的变量保存的是一个指向堆区的指针，通过这个指针，就可以找到这个实例在堆区对应的对象。因此，普通类型变量只在栈区占用一块内存，而引用类型变量要在栈区和堆区各占一块内存。

===========================================

单列模式
1. 懒汉模式
复制代码

public class SingletonDemo {
    private static SingletonDemo instance;
    private SingletonDemo(){

    }
    public static SingletonDemo getInstance(){
        if(instance==null){
            instance=new SingletonDemo();
        }
        return instance;
    }

=========================================

 TCP和UDP的优缺点及区别

TCP的优点： 可靠，稳定 TCP的可靠体现在TCP在传递数据之前，会有三次握手来建立连接，而且在数据传递时，有确认、窗口、重传、拥塞控制机制，在数据传完后，还会断开连接用来节约系统资源。 TCP的缺点： 慢，效率低，占用系统资源高，易被攻击 TCP在传递数据之前，要先建连接，这会消耗时间，而且在数据传递时，确认机制、重传机制、拥塞控制机制等都会消耗大量的时间，而且要在每台设备上维护所有的传输连接，事实上，每个连接都会占用系统的CPU、内存等硬件资源。 而且，因为TCP有确认机制、三次握手机制，这些也导致TCP容易被人利用，实现DOS、DDOS、CC等攻击。

UDP的优点： 快，比TCP稍安全 UDP没有TCP的握手、确认、窗口、重传、拥塞控制等机制，UDP是一个无状态的传输协议，所以它在传递数据时非常快。没有TCP的这些机制，UDP较TCP被攻击者利用的漏洞就要少一些。但UDP也是无法避免攻击的，比如：UDP Flood攻击…… UDP的缺点： 不可靠，不稳定 因为UDP没有TCP那些可靠的机制，在数据传递时，如果网络质量不好，就会很容易丢包。 基于上面的优缺点，那么： 什么时候应该使用TCP： 当对网络通讯质量有要求的时候，比如：整个数据要准确无误的传递给对方，这往往用于一些要求可靠的应用，比如HTTP、HTTPS、FTP等传输文件的协议，POP、SMTP等邮件传输的协议。 在日常生活中，常见使用TCP协议的应用如下： 浏览器，用的HTTP FlashFXP，用的FTP Outlook，用的POP、SMTP Putty，用的Telnet、SSH QQ文件传输 ………… 什么时候应该使用UDP： 当对网络通讯质量要求不高的时候，要求网络通讯速度能尽量的快，这时就可以使用UDP。 比如，日常生活中，常见使用UDP协议的应用如下： QQ语音 QQ视频 TFTP ……

有些应用场景对可靠性要求不高会用到UPD，比如长视频，要求速率

小结TCP与UDP的区别：

1.基于连接与无连接；
2.对系统资源的要求（TCP较多，UDP少）；
3.UDP程序结构较简单；
4.流模式与数据报模式 ；

5.TCP保证数据正确性，UDP可能丢包，TCP保证数据顺序，UDP不保证。

tcp协议和udp协议的差别
TCP UDP
是否连接 面向连接 面向非连接
传输可靠性 可靠 不可靠
应用场合 传输大量数据 少量数据
速度 慢 快

TCP与UDP区别总结：

1、TCP面向连接（如打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接

2、TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP尽最大努力交付，即不保证可靠交付

3、TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流;UDP是面向报文的

UDP没有拥塞控制，因此网络出现拥塞不会使源主机的发送速率降低（对实时应用很有用，如IP电话，实时视频会议等）

4、每一条TCP连接只能是点到点的;UDP支持一对一，一对多，多对一和多对多的交互通信

5、TCP首部开销20字节;UDP的首部开销小，只有8个字节

6、TCP的逻辑通信信道是全双工的可靠信道，UDP则是不可靠信道

 ========================================================

Netty：客户端和服务器连接，当有连接的时候，创建一个channel,进行监听
客户端循环的发送心跳包，连接发送消息，当有消息的时候，进行判断，当有消息的时候，设置一个用户id,然后把用户设置为登录状态，如果消息是心跳，那么空闲数就为零，当channel是空闲的，那么设置空闲数+1，判断空闲数是否大于三，当大于三断开channel,并把用户设置为离线状态
========================================================

spring的工作原理

1.springmvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。

2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.

3.DispatcherServlet请请求提交到目标Controller

4.Controller进行业务逻辑处理后，会返回一个ModelAndView

5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象

6.视图对象负责渲染返回给客户端。

为什么要使用Spring：

AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP后，公共服务（比如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。

IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反过来的JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straightconstruction），每一个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。

Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了Spring，只要用JavaBean属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring模块构建在核心容器之上，核心容器定义了创建、配置和管理bean 的方式，如图 1 所示。

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

核心容器：核心容器提供 Spring框架的基本功能。核心容器的主要组件是BeanFactory，它是工厂模式的实现。BeanFactory使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

Spring 上下文：Spring 上下文是一个配置文件，向 Spring框架提供上下文信息。Spring上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。

Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了Spring框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于Spring的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖EJB组件，就可以将声明性事务管理集成到应用程序中。

Spring  DAO：JDBCDAO抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。SpringDAO的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。

Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM的对象关系工具，其中包括JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和DAO异常层次结构。

Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于Web的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts的集成。Web模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC实现。通过策略接口，MVC框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括JSP、Velocity、Tiles、iText 和 POI。

spring 框架的功能可以用在任何 J2EE服务器中，大多数功能也适用于不受管理的环境。Spring的核心要点是：支持不绑定到特定 J2EE服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同 J2EE 环境 （Web或EJB）、独立应用程序、测试环境之间重用。
---------------------