随笔

分页查询：逻辑分页和物理分页。

逻辑分页：第一次全部查出，存放到session，通过页码计算，进行遍历显示。 后面的访问从session取。Session中分页而不是数据库。缺点，数据量大时，session占内存，并且都是第一次数据，不实时。在数据量小并且数据不改变是可用来提高效率。

物理分页：（常用：原理用的数据库的分页技术，如mysql的limit，sql的top，oracl的rownum），采用hibernate框架时流程：

单例模式：应用场景（加载配置文件【整个生命周期只需要一份】，spring管理bean默认也是单例，scope属行决定，但这里使用单例的bean都是无状态的bean；但是管理struts2的action时scope必须为prototype，因为是有状态的【每个bean对应了不同的请求】，每个请求都要创建一个action，所以这里不能用单例）。

1.饿汉试：类加载时实例化，线程安全，但是没有实现延迟加载，如果实例未用到可能会造成内存浪费。

public class Singleton {

    private finalstatic Singleton singleton = new Singleton();

    privateSingleton(){}

    public staticSingleton getInstance(){

        return singleton;

    }

}

2.懒汉试的doubble-check（双重检测）：线程安全；延迟加载；效率较高（同步代码块里的代码不能分开，是一次执行完的，虽然第一次判断有可能会被其他线程打断，但是只有第一个拿到同步锁的实例化了，其他的线程在进入后，因为有第二次判断所以都不会实例化）

public class Singleton {

    private static volatile Singleton singleton;

    private Singleton() {}

    public static Singleton getInstance() {

        if (singleton == null) {

            synchronized (Singleton.class) {

                if (singleton == null) {

                    singleton = new Singleton();

                }

            }

        }

        return singleton;

    }

}

3.静态内部类（也是类加载时实例化，但是是静态内部类加载时实例化，静态内部类实在其内部的方法，成员等被用到时在加载静态内部类的，他不是随外部内加载而加载，而这个调用又放到了getInstance里从而实现了延迟加载）线程安全，延迟加载。

public class Singleton {

    private Singleton() {}

    private static class SingletonInstance {

        private static final Singleton singleton = new Singleton();

    }

    public static Singleton getInstance() {

        return SingletonInstance.singleton;

    }

}

 

创建线程：

1.       继承Thread类

public class MyThread extends Thread {
　　public void run() {
　　 System.out.println("MyThread.run()");
　　}
}

MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();

2.       实现Runnable接口

如果自己的类已经extends另一个类，就无法直接extends Thread，此时，必须实现一个Runnable接口，如下：
public class MyThread extends OtherClass implements Runnable {
　　public void run() {
　　 System.out.println("MyThread.run()");
　　}
}
为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：
MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();

排序：（时间复杂度n²）

冒泡：publicclass Test{

 

    publicstaticvoid main(String[] args){

        int[] array={1,2,5,3,4};

        bubbleSort(array);

        for(inti=0;i<array.length;i++){

            System.out.println(array[i]);

        }

    }

    public  staticvoidbubbleSort(int[]arr){

        for(inti=0;i<arr.length-1;i++){

            for(intj=0;j<arr.length-1-i;j++){

                if(arr[j]>arr[j+1]){

                    swap(arr,j,j+1);

                }

            }

        }

    }

 

    public  staticvoidswap(int[]arr,inti,intj){

        inttemp=arr[i];

        arr[i]=arr[j];

        arr[j]=temp;

    }

}

选择：（时间复杂度n²）

publicclassTest{

 

    publicstaticvoid main(String[] args){

        int[] array={1,2,5,3,4};

        selectSort(array);

        System.out.println(Arrays.toString(array));

    }

    public  staticvoidselectSort(int[]arr){

        for(inti=0;i<arr.length-1;i++){

            intmin=i;//记录下标

            for(intj=i+1;j<arr.length;j++){

                if(arr[min]>arr[j]){

                    min=j;

                }

            }

            if(min!=i){//现在的min为j了

                inttemp=arr[min];

                arr[min]=arr[i];

                arr[i]=temp;

            }

        }

    }

}

快速：（时间复杂度nlogn）

import java.util.Arrays;

 

publicclassTest{

 

    publicstaticvoid main(String[] args){

        int[] array={8,5,3,4,6,10,2,7};

        intlow=0;

        inthigh=array.length-1;

        FastSort(array,low,high);

        System.out.println(Arrays.toString(array));

    }

    public  staticvoidFastSort(int[]arr,intlow,inthigh){

        intstart=low;

        intend=high;

        intkey=arr[start];

        while(start<end){

            //从后往前，比key小的放到左边

            while(start<end&&arr[end]>=key){

                end--;

            }

            if(arr[end]<=key){

                inttemp=arr[start];

                arr[start]=arr[end];

                arr[end]=temp;

            }

            //从前往后，比key大的放到右边

            while(start<end&&arr[start]<=key){

                start++;

            }

            if(arr[start]>=key){

                inttemp=arr[start];

                arr[start]=arr[end];

                arr[end]=temp;

            }

        }

        //这时start==end；取到了中间位置；

        if(start>low) FastSort(arr,low,start-1);//左边序列。第一个索引位置到关键值索引-1

        if(end<high)FastSort(arr,end+1,high);//右边序列。从关键值索引+1到最后一个

    }

}

性能优化：1.硬件优化；2：还可以建一个单独的表来保存最新一条数据，这样实时数据就可以不用从历史表查了，得到实时性。3：使用缓存（具体使用哪种缓存，看下面的缓存分类。）

缓存的分类：

客户端缓存：1.浏览器缓存：可以设置meta标签设置，用户在访问同一个页面时，将不再从服务器下载页面，而是从本机的缓存目录中读取页面，然后再浏览器中展现这个页面。2.网关、代理服务器缓存：将网页缓存中网关服务器上，多用户访问同一个页面时，将直接从网关服务器把页面传送给用户。

服务端缓存：1.页面缓存：将动态页面直接生成静态的页面放在服务器端，用户调取相同页面时，静态页面将直接下载到客户端，不再需要通过程序的运行和数据库的访问，大大节约了服务器的负载。2. 数据缓存：a.需要独立安装的，独立运行，如redis，memcache（区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。）；b.与java服务程序绑定在一起，java程序活着，它就活着，可以让数据保存在不同服务器的内存中，如ehcache。

数据库缓存：比如mysql的QUERY cache，一般只有在数据更新很少的表采用（如博客系统，一般博客更新相对较慢），因为每次表的改动都会清除缓存的，如果数据经常更新反而会带来新的开销。

项目采用了redis作为实时数据的缓存，用户，角色等使用了hibernate+ehcache配置的二级缓存。

数据库操作

创件数据库：create database stuDB ，删除数据库：drop database stuDB，创建表：

createtabledbo.Ywj4Collect (

  ID                   bigint               identity(1, 1),

  Alarm                tinyint              notnull,

  CreateDate           datetime             notnull,

  status               tinyint              notnullconstraintDF__Ywj4Colle__statu__544C7222 default (1),

  constraintPK_YWJ4COLLECT primarykey(id)

)

Sql增删改查：

增：1.插入单行：insert into Strdents (姓名,性别,出生日期) values ('开心朋朋','男','1980/6/15')2.跨表插入：insert into tongxunlu ('姓名','地址','电子邮件') selectname,address,email from Strdents

3.库数据库插入：Insert into City(ID,RegionName,Regionlevel,ParentId,Displayorder,Latitude,Longtitude)select ID,RegionName,Regionlevel,ParentId,Displayorder,Latitude,Longtitude FROM[THTDB].[dbo].[City]

删：1.删除行：delete from Person where name='开心朋朋'2.删除整个表：A. DROPPerson 表名称; B.truncate table tongxunlu（但表的结构、列、约束、索引等不会被删除）;C. DELETE FROM Person ;注意：drop不会保留表结构，而delete和truncate会保留表结构只删除数据，但是delete删了数据是放在系统回滚段中，可回滚，truncate不可回滚，delete自增字段仍保留原来的最大数值，truncate自增字段从头开始计数了。

改：update tongxunlu set 年龄=18 where 姓名='蓝色小名'

查：1. select * from a；2. select i,j,k from a where f=5；3.查空行 selectname from a where email is null；4. select top 6 name from a；5. 模糊查询select *from a where name like '赵%'；6. 查范围select * from a where nianling between 18 and 20；7. 用in在列举值内查询：selectname from a where address in ('北京','上海','唐山')；8. 分组查询：SELECT Customer,SUM(OrderPrice) FROM Orders GROUP BY Customer；9. 使用having子句进行分组筛选（因为where子句中不能有聚合函数）SELECTCustomer,SUM(OrderPrice) FROM Orders GROUP BY Customer HAVINGSUM(OrderPrice)<2000；10.内连接（公有数据）：select a.name,b.chengji from a,b where a.name=b.name或者selecta.name,b.chengji from a inner join b on a.name=b.name；11.左外链接（a表加公有数据）：selecta.name,b.chengji from a left outer join b on a.name=b.name；12.右外连接（公有数据加b表）：selecta.name,b.chengji from a right outer join b on a.name=b.name；

添加字段：alter Table LeftMenu add typeids varchar(20);修改字段类型：alterTable LeftMenu alter column typeids varchar(50);删除字段：alter TableLeftMenu drop column typeids;

 

 

 

定时器：

1.timer：第一步：创建要被定执行的任务类（extends TimeTask，重写run方法）；第二步：timer = new Timer();timer.schedule(new LzstoneTimeTask(),0,1*1000); 也可以用web监听执行，配个监听器，事件触发执行

2.quartz：　第一步：引包，第二步：创建要被定执行的任务类（实现了org.quartz.Job接口的类，实现方法execute）；第三步：创建任务调度，并直接执行（也可以用web监听执行，配个监听器，事件触发执行），创建Schedule实例，创建一个包含任务信息的JobDetail，最后创建一个Trigger管理任务的执行，最后将两者加入schedule。

比较：quartz定时比较灵活，可以实现复杂的定时如：每个月最后一天触发，每个月最后一周星期五触发等，这个查表就可以出来。Timer是简单的定时。

Spring管理定时器：

 

Struts2启动过程：获取用户请求后，如：/strutsDeepen/loginAction.action，URL中的web上下文，也就是“/strutsDeepen”，Web容器会去读取strutsDeepen这个工程的web.xml，配置有过滤器，来处理loginAction.action，

过滤器创建ActionProxy对象。在服务器启动的时候，ConfigurationManager会一次性的把struts.xml中的所有信息读到内存里，并缓存起来；ActionProxy对象找ConfigurationManager拿到要处理的Action，相关的拦截器以及所有可能使用的result信息，建立ActionInvocation对象，ActionInvocation对象首先，按照拦截器的引用顺序依次执行各个拦截器的前置部分；然后，执行Action的execute方法；然后，根据execute方法返回的结果，也就是Result，在struts.xml中匹配选择下一个页面；找到页面后，由于现在的页面一般都是模板页面，在页面上，可以通过Struts2自带的标签库来访问需要的数据，并生成最终页面；接着ActionInvocation对象再按照拦截器的引用顺序的倒序依次执行各个拦截器的后置部分。最后ActionInvocation对象执行完毕后，实际上就已经得到响应对象了，也就是HttpServletResponse对象，最后按与过滤器器配置定义相反的顺序依次经过过滤器，向用户展示出响应的结果。

Spring启动过程：在web配置文件例加入spring的配置文件和ContextLoaderListener 监听器，通过ContextLoaderListener监听器类启动，通过配置文件完成spring的初始化。ContextLoaderListener extends ContextLoader implements ServletContextListener， ServletContextListener有两个方法：contextInitialized和contextDestroyed，web应用启动时会自动调用contextInitialized，结束时调用contextDestroyed，这些是事件响应的。所以分别在这两个方法里初始化和销毁Spring上下文，而初始化和销毁Spring上下文又是由ContextLoader实现的。

Hibernate：

hibernate，通过对jdbc进行封装，对 java类和关系数据库进行mapping，实现了对关系数据库的面向对象方式的操作.

/首先获得 SessionFactory 的对象

 SessionFactory sessionFactory =new Configuration().configure().

                                        buildSessionFactory();

//然后获得 session 的对象

      Session session = sessionFactory.openSession();

//其次获得 Transaction 的对象

 Transaction tx =session.beginTransaction();

 //执行相关的数据库操作:增,删,改,查

 session.save(user);

//增加, user 是 User 类的对象

 session.delete(user);

//删除

      session.update(user);

//更新

 Query query =session.createQuery(“from User”);

//查询

      List list = query.list();

 //提交事务

 tx.commit();

 //如果有异常,我们还要作事务的回滚,恢复到操作之前

 tx.rollback();

 //最后还要关闭session,释放资源

session.close();

 hibernate缓存：

第一级是Session的缓存。由于Session对象的生命周期通常对应一个数据库事务或者一个应用事务，因此它的缓存是事务范围的缓存。

第二级缓存是一个可插拔的的缓存插件，它是由SessionFactory负责管理。由于SessionFactory对象的生命周期和应用程序的整个过程对应，因此第二级缓存是进程范围或者集群范围的缓存。

二级缓存：1) 条件查询的时候，总是发出一条select * from table_name where …. （选择所有字段）这样的SQL语句查询数据库，一次获得所有的数据对象。

2) 把获得的所有数据对象根据ID放入到第二级缓存中。

3) 当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；查不到，如果配置了二级缓存，那么从二级缓存中查；查不到，再查询数据库，把结果按照ID放入到缓存。

二级缓存适合放的数据：很少被修改的数据；不会被并发访问的数据；常量数据 　。

 

 

三种查询：

本地SQL查询、Criteria、Hql

Hibernate中持久化对象的生命周期有临时态、持久态和游离态三种。

处于临时态的对象主键值为空，并且未与session关联，数据未保存到数据库中

处于持久态的对象与session关联起来，持久化后对象中的数据被保存到数据库中，并且主键值按照.hbm.xml文件中配置的生成方式生成相应的值

处于游离态的对象脱离了session的管理，是持久化后的一种状态，主键值按照.hbm.xml文件中配置的生成方式生成相应的值

当new一个新的对象时，该对象处于临时态

当该对象被当作session的参数使用的时候，该对象处于持久态

事务提交，session关闭后，该对象处于游离态

 

 

 

Apache: Web服务器, 静态解析，如HTML, Web服务器专门处理HTTP请求，解析静态html速度快，稳定性高；

Tomcat: 运行在Apache上的应用服务器, 动态解析，如JSP、PHP；可以独立于Apache运行；

整合后运行的流程：如果客户端请求的是静态页面，则只需要Apache服务器响应请求；

　　　如果客户端请求动态页面，则是Tomcat服务器响应请求，将解析的JSP等网页代码解析后回传给Apache服务器，再经Apache返回给浏览器端。

　　　这是因为jsp是服务器端解释代码的，Tomcat只做动态代码解析，Apache回传解析好的静态代码，Apache+Tomcat这样整合就可以减少Tomcat的服务开销。

 

Netty框架过程：

1.  工程需加载netty的jar包

2.  Netty交给spring管理，通过spring注解@PostConstruct，spring启动后会自动扫描，通过spring来管理netty服务器端的编写，netty是基于事件驱动的，注册receivehandler，在里面写上事件方法，在messageReceived接受到信息后，讲接受的数据解码，然后再对解码后的内容处理即可，如判断，比较，存数据库等操作。

分页查询：逻辑分页和物理分页。

逻辑分页：第一次全部查出，存放到session，通过页码计算，进行遍历显示。 后面的访问从session取。Session中分页而不是数据库。缺点，数据量大时，session占内存，并且都是第一次数据，不实时。在数据量小并且数据不改变是可用来提高效率。

物理分页：（常用：原理用的数据库的分页技术，如mysql的limit，sql的top，oracl的rownum），采用hibernate框架时流程：

数据库连接池：

线程池：s

权限管理：