2018年上海后半年JAVA软件工程师面试真题_上海意盟软件java面试

SELECT deptid FROM table1

GROUP BY deptid

HAVING COUNT(deptid) > 3

1. package com.day01;
2.  
3. public class 单例模式 {
4.  
5.  
6. private final static 单例模式 INSTANCE = new 单例模式();
7.  
8. private 单例模式(){
9.    
10. }
11.  
12. public static 单例模式  getInstance(){
13.     return INSTANCE;
14. }
15. }

package com.day01;

public class 冒泡排序 {

   public static void main(String[] args) {

      int[] arr = {3,2,1};

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

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

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

                int temp = arr[j];

                arr[j] = arr[j+1];

                arr[j+1] = temp;

            }

         }

      }

      System.out.println(arr[0]);

      System.out.println(arr[1]);

      System.out.println(arr[2]);

   }

}

package com.day01;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.InputStreamReader;

public class 找关键字次数 {

   public static void main(String[] args) throws Exception {

      StringBuilder sBuilder = new StringBuilder();   // 创建拼接字符串

      File file = new File("F:\\get.txt");   // 读取文件

      //创建IO留独处文件

       InputStreamReader isr = new InputStreamReader(new FileInputStream(file), "utf-8");

       BufferedReader br = new BufferedReader(isr);

       //用于暂时保存文本内容

       String lineTxt = null;

       //循环读取

       while ((lineTxt = br.readLine()) != null) {

         sBuilder.append(lineTxt);

       }

       br.close();

      String srcText = sBuilder.toString();

      String findText = "d";

      int num = appearNumber(srcText,findText);

      System.out.println(num);

   }

   public static int appearNumber(String srcText,String findText){

      int count = 0;

      int index = 0;

      while((index = srcText.indexOf(findText,index)) != -1){

         index = index + findText.length();

         count++;

      }

      return count;

   }

}

// 访问权限   类   包  子类  其他包

public String aString;

   // 继承的类可以访问以及和private一样的权限

   protected String bString;

   // 包访问权限，即在整个包内均可被访问

   /*default*/ String cString;

   //除类型创建者和类型的内部方法之外的任何人都不能访问的元素

   private String dString;

在Spring的配置文件中

  <!-- 使用annotation定义事务 -->

事务：

<tx:annotation-driven transaction-manager="defaultTransactionManager" proxy-target-class="true" />

<context：component-scan base-package =“xx.test.*”use-default-filters =“false”>

第一，通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。

第二，可以大大加快数据的检索速度，这也是创建索引的最主要的原因。

第三，可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。

第四，在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。

第五，通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。

索引类型

普通索引，唯一索引，主键索引，组合索引

索引的创建

◆创建索引

CREATE INDEX indexName ON mytable(username(length)); 
如果是CHAR，VARCHAR类型，length可以小于字段实际长度；如果是BLOB和TEXT类型，必须指定 length，下同。

◆修改表结构

ALTER mytable ADD INDEX [indexName] ON (username(length))

◆创建表的时候直接指定

CREATE TABLE mytable( ID INT NOT NULL, username VARCHAR(16) NOT NULL, 
INDEX [indexName] (username(length)) ); 删除索引的语法：

DROP INDEX [indexName] ON mytable;

每个线程都有要执行的任务。线程的任务处理逻辑可以在Tread类的run实例方法中直接实现或通过该方法进行调用，因此

run()相当于线程的任务处理逻辑的入口方法，它由Java虚拟机在运行相应线程时直接调用，而不是由应用代码进行调用。

而start()的作用是启动相应的线程。启动一个线程实际是请求Java虚拟机运行相应的线程，而这个线程何时能够运行是由线程调度器决定的。start()调用结束并不表示相应线程已经开始运行，这个线程可能稍后运行，也可能永远也不会运行。

第一是创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。
　　第二是就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。
　　第三是运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。
　　第四是阻塞状态。线程正在运行的时候，被暂停，通常是为了等待某个事件的发生(比如说某项资源就绪)之后再继续运行。sleep，suspend，wait等方法都可以导致线程阻塞。
　　第五是死亡状态。如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪。

创建索引可以大大提高系统的性能:
第一，通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。
第二，可以大大加快数据的检索速度，这也是创建索引的最主要的原因。
第三，可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
第四，在使用分组和排序 子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。
第五，通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。

增加索引也有许多不利的方面:
第一，创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。
第二，索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大。
第三，当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。

跨域是指a页面想获取b页面资源，如果a、b页面的协议、域名、端口、子域名不同，或是a页面为ip地址，b页面为域名地址，所进行的访问行动都是跨域的，而浏览器为了安全问题一般都限制了跨域访问，也就是不允许跨域请求资源。

解决跨域：

Jsonp，把请求路径转成jsonp的格式，再进行请求

在Contoller中加：

       // 设置：Access-Control-Allow-Origin头，处理Session问题

               response.setHeader("Access-Control-Allow-Origin", request.getHeader("Origin"));

               response.setHeader("Access-Control-Allow-Credentials", "true");

               response.setHeader("P3P", "CP=CAO PSA OUR");

               if (request.getHeader("Access-Control-Request-Method") != null && "OPTIONS".equals(request.getMethod())) {

                   response.addHeader("Access-Control-Allow-Methods", "POST,GET,TRACE,OPTIONS");

                   response.addHeader("Access-Control-Allow-Headers", "Content-Type,Origin,Accept");

                   response.addHeader("Access-Control-Max-Age", "120");

               }

SpringBoot跨域解决方案:

在Controller上加@CrossOrigin

收集并删除未引用的对象。可以通过调用"System.gc()"来触发垃圾回收，但并不保证会确实进行垃圾回收。

JVM的垃圾回收只收集哪些由new关键字创建的对象。所以，如果不是用new创建的对象，你可以使用finalize函数来执行清理。

1 #是将传入的值当做字符串的形式，eg:select id,name,age from student where id =#{id},当前端把id值1，传入到后台的时候，就相当于 select id,name,age from student where id ='1'.

 2 $是将传入的数据直接显示生成sql语句，eg:select id,name,age from student where id =${id},当前端把id值1，传入到后台的时候，就相当于 select id,name,age from student where id = 1.

 3 使用#可以很大程度上防止sql注入。(语句的拼接)

 4 但是如果使用在order by 中就需要使用 $.

 5 在大多数情况下还是经常使用#，但在不同情况下必须使用$. 

方式一，利用HashSet不能添加重复数据的特性 由于HashSet不能保证添加顺序，所以只能作为判断条件：

private static void removeDuplicate(List<String> list) {

    HashSet<String> set = new HashSet<String>(list.size());

    List<String> result = new ArrayList<String>(list.size());

    for (String str : list) {

        if (set.add(str)) {

            result.add(str);

        }

    }

    list.clear();

    list.addAll(result);

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

方式二，利用LinkedHashSet不能添加重复数据并能保证添加顺序的特性 ：

private static void removeDuplicate(List<String> list) {

    LinkedHashSet<String> set = new LinkedHashSet<String>(list.size());

    set.addAll(list);

    list.clear();

    list.addAll(set);

}

• 1
• 2
• 3
• 4
• 5
• 6

方式三，利用List的contains方法循环遍历：

private static void removeDuplicate(List<String> list) {

    List<String> result = new ArrayList<String>(list.size());

    for (String str : list) {

        if (!result.contains(str)) {

            result.add(str);

        }

    }

    list.clear();

    list.addAll(result);

}

--------------------- 作者：灰色流连 来源：CSDN 原文：https://blog.csdn.net/u012156163/article/details/78338574?utm_source=copy 版权声明：本文为博主原创文章，转载请附上博文链接！

Redis存储机制分成两种Snapshot和AOF。无论是那种机制,Redis都是将数据存储在内存中。

方式1：

HttpClient：可以用来调用webservie服务，也可以抓取网页数据

版本1：HttpClient3.0.x

版本2：HttpClient4.x.x(目前最新4.5.2)

这2个版本的使用方式不一样；变动较大

方式2：纯Java(自带API)      jws

方式3：cxf框架

方式4：axis2框架

准备工作:

1.了解wsimport        java自带的一个命令（建议使用jdk7，稳定支持）

作用：将wsdl文件生成本地代理（java代码），方便调用

语法  wsimport [opations] <wsdl_uri>
    - wsdl_uri:wsdl 的统一资源标识符
    - d  ：指定要输出的文件的位置
    - s  ：表示要解析java的源码 ，默认解析出的是class字节码 
    - p  ： 指定输出的包名
 
1. 获取服务路径:比如
  http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx?WSDL


2. 获取wsdl文件.建议使用JDK1.6以上的版本的wsimport命令


进入dos的桌面：
方式1：wsimport http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx?WSDL
这种默认只会生成class，且会生成默认的包
方式2：生成源码，指定包和路径
wsimport -s ./ -p cn.aa http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx?WSDL


3.可以把class文件打成jar包 jar cvf  test.jar  打包目录

4.放在你的项目中进行调用：

[html] view plain copy

1. public static void main(String[] args) {  
2.         MobileCodeWS mobileCodeWs=new MobileCodeWS();  
3.         MobileCodeWSSoap mobileCodeWSSoap=mobileCodeWs.getMobileCodeWSSoap();  
4.         String tel=mobileCodeWSSoap.getMobileCodeInfo("183735xxxx",null);  
5.         System.out.println(tel);  
6.     }  

1. 用volatile关键字
2. 用redis实现

1. volatile主要用在多个线程感知实例变量被更改了场合，从而使得各个线程获得最新的值。它强制线程每次从主内存中讲到变量，而不是从线程的私有内存中读取变量，从而保证了数据的可见性。
2.  
3. 关于synchronized，可参考：JAVA多线程之Synchronized关键字--对象锁的特点
4.  
5. 比较：
6.  
7. ①volatile轻量级，只能修饰变量。synchronized重量级，还可修饰方法
8.  
9. ②volatile只能保证数据的可见性，不能用来同步，因为多个线程并发访问volatile修饰的变量不会阻塞。
10.  
11. synchronized不仅保证可见性，而且还保证原子性，因为，只有获得了锁的线程才能进入临界区，从而保证临界区中的所有语句都全部执行。多个线程争抢synchronized锁对象时，会出现阻塞。
12.  
13.  
14.  
15. 四，线程安全性
16.  
17. 线程安全性包括两个方面，①可见性。②原子性。
18.  
19. 从上面自增的例子中可以看出：仅仅使用volatile并不能保证线程安全性。而synchronized则可实现线程的安全性。

scheduler（调度器）：将job和trigger绑定在一起

job（任务）              ：配置具体哪个类实现定时任务

trigger（触发器）     ：配置定时器参数，如：多久执行一次，执行多上次等

开启注解

服务端丢失

把内存中的消息持久化，重启mq的时候进行从持久化文件中读取

客户端丢失

用户发出的消息还依旧在缓存中，mq可以重新进行read

消息确认

RabbitMQ引入了消息确认机制，当消息处理完成后，给Server端发送一个确认消息，来告诉服务端可以删除该消息了，如果连接断开的时候，Server端没有收到消费者发出的确认信息，则会把消息转发给其他保持在线的消费者。

1、 配置 applicationContext-shiro.xml 激活注解

<!-- 开启shiro注解模式  -->
    <bean
        class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
        depends-on="lifecycleBeanPostProcessor" >
        <property name="proxyTargetClass" value="true" />
    </bean>
        
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
         <property name="securityManager" ref="securityManager"/>
    </bean>

2.业务层使用 shiro 注解

@RequiresPermissions("")

3.使用方法注解进行权限控制， 当权限不足时，代理对象抛出一个异常
org.apache.shiro.authz.UnauthorizedException: Subject does not
have permission [courier_add]

GET： 请求指定的页面信息，并返回实体主体。 
HEAD： 只请求页面的首部。 
POST： 请求服务器接受所指定的文档作为对所标识的URI的新的从属实体。 
PUT： 从客户端向服务器传送的数据取代指定的文档的内容。 
DELETE： 请求服务器删除指定的页面。 
OPTIONS： 允许客户端查看服务器的性能。 
TRACE： 请求服务器在响应中的实体主体部分返回所得到的内容。 
PATCH： 实体中包含一个表，表中说明与该URI所表示的原内容的区别。 
MOVE： 请求服务器将指定的页面移至另一个网络地址。 
COPY： 请求服务器将指定的页面拷贝至另一个网络地址。 
LINK： 请求服务器建立链接关系。 
UNLINK： 断开链接关系。 
WRAPPED： 允许客户端发送经过封装的请求。 

3、二者优缺点

RDB存在哪些优势呢？

1). 一旦采用该方式，那么你的整个Redis数据库将只包含一个文件，这对于文件备份而言是非常完美的。比如，你可能打算每个小时归档一次最近24小时的数 据，同时还要每天归档一次最近30天的数据。通过这样的备份策略，一旦系统出现灾难性故障，我们可以非常容易的进行恢复。

2). 对于灾难恢复而言，RDB是非常不错的选择。因为我们可以非常轻松的将一个单独的文件压缩后再转移到其它存储介质上。

3). 性能最大化。对于Redis的服务进程而言，在开始持久化时，它唯一需要做的只是fork出子进程，之后再由子进程完成这些持久化的工作，这样就可以极大的避免服务进程执行IO操作了。

4). 相比于AOF机制，如果数据集很大，RDB的启动效率会更高。

RDB又存在哪些劣势呢？

1). 如果你想保证数据的高可用性，即最大限度的避免数据丢失，那么RDB将不是一个很好的选择。因为系统一旦在定时持久化之前出现宕机现象，此前没有来得及写入磁盘的数据都将丢失。

2). 由于RDB是通过fork子进程来协助完成数据持久化工作的，因此，如果当数据集较大时，可能会导致整个服务器停止服务几百毫秒，甚至是1秒钟。

AOF的优势有哪些呢？

1). 该机制可以带来更高的数据安全性，即数据持久性。Redis中提供了3中同步策略，即每秒同步、每修改同步和不同步。事实上，每秒同步也是异步完成的，其 效率也是非常高的，所差的是一旦系统出现宕机现象，那么这一秒钟之内修改的数据将会丢失。而每修改同步，我们可以将其视为同步持久化，即每次发生的数据变 化都会被立即记录到磁盘中。可以预见，这种方式在效率上是最低的。至于无同步，无需多言，我想大家都能正确的理解它。

2). 由于该机制对日志文件的写入操作采用的是append模式，因此在写入过程中即使出现宕机现象，也不会破坏日志文件中已经存在的内容。然而如果我们本次操 作只是写入了一半数据就出现了系统崩溃问题，不用担心，在Redis下一次启动之前，我们可以通过redis-check-aof工具来帮助我们解决数据 一致性的问题。

3). 如果日志过大，Redis可以自动启用rewrite机制。即Redis以append模式不断的将修改数据写入到老的磁盘文件中，同时Redis还会创 建一个新的文件用于记录此期间有哪些修改命令被执行。因此在进行rewrite切换时可以更好的保证数据安全性。

4). AOF包含一个格式清晰、易于理解的日志文件用于记录所有的修改操作。事实上，我们也可以通过该文件完成数据的重建。

AOF的劣势有哪些呢？

1). 对于相同数量的数据集而言，AOF文件通常要大于RDB文件。RDB 在恢复大数据集时的速度比 AOF 的恢复速度要快。

2). 根据同步策略的不同，AOF在运行效率上往往会慢于RDB。总之，每秒同步策略的效率是比较高的，同步禁用策略的效率和RDB一样高效。

二者选择的标准，就是看系统是愿意牺牲一些性能，换取更高的缓存一致性（aof），还是愿意写操作频繁的时候，不启用备份来换取更高的性能，待手动运行save的时候，再做备份（rdb）。rdb这个就更有些 eventually consistent的意思了。

4、常用配置

RDB持久化配置

Redis会将数据集的快照dump到dump.rdb文件中。此外，我们也可以通过配置文件来修改Redis服务器dump快照的频率，在打开6379.conf文件之后，我们搜索save，可以看到下面的配置信息：

save 900 1              #在900秒(15分钟)之后，如果至少有1个key发生变化，则dump内存快照。

save 300 10            #在300秒(5分钟)之后，如果至少有10个key发生变化，则dump内存快照。

save 60 10000        #在60秒(1分钟)之后，如果至少有10000个key发生变化，则dump内存快照。

AOF持久化配置

在Redis的配置文件中存在三种同步方式，它们分别是：

appendfsync always     #每次有数据修改发生时都会写入AOF文件。

appendfsync everysec  #每秒钟同步一次，该策略为AOF的缺省策略。

appendfsync no          #从不同步。高效但是数据不会被持久化。

Scanner input = new Scanner(System.in);

        // TODO 自动生成的方法存根

       System.out.println("请输入行数:");

       int m=input.nextInt();

       //确定打印菱形的行数，可以自行设置

       int n=m/2+1;

       int t=m/2;

       for(int i=1;i<=n;i++)//打印菱形的上半部分

       {

           for(int j=(n-i);j>0;j--)

               System.out.print(" ");

             //打印空格数 

           for(int k=2*i-1;k>0;k--)

               System.out.print("*");

              //打印*号

           System.out.println();

           //一行打印结束，换行

       }

       for(int i=t;i>0;i--)//打印菱形的下半部分

       {

           for (int b=(n-i);b>0;b--)

               System.out.print(" ");

               //打印空格数

           for (int a=(2*i-1);a>0;a--)

               System.out.print("*");

               //打印*号

           System.out.println();

           //一行打印结束，换行

       }

        }

       System.out.println("43 编写程序，对输入的年、月、日，给出该天是该年的第多少天？");

             // 编写程序，对输入的年、月、日，给出该天是该年的第多少天？

             SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");

             Date date;

             Date date1;

             Scanner sc = new Scanner(System.in);

             while (true){

                 System.out.print("请输入一个日期\n【格式】yyyy-MM-dd\n请输入:");

                 String temp = sc.next();

                 try {

                     date = format.parse(temp);

                     date1 = format.parse(temp.split("-")[0]+"-01-01");

                     break;

                 } catch (ParseException e) {

//                       e.printStackTrace();

                     System.out.println("输入有误!");

                 }

             }//getTime() 方法可返回距 1970 年 1 月 1 日之间的毫秒数。

             long l = date.getTime() - date1.getTime();

             //毫秒 / 1000 = 秒 / 60 = 分钟 / 60 = 小时 / 24 = 天 + 1 = 第几天

             System.out.println("该天是该年的第"+((l)/1000/60/60/24+1)+"天");

　1.标记-清除算法

　　等待被回收对象的“标记”过程在上文已经提到过，如果在被标记后直接对对象进行清除，会带来另一个新的问题——内存碎片化。如果下次有比较大的对象实例需要在堆上分配较大的内存空间时，可能会出现无法找到足够的连续内存而不得不再次触发垃圾回收。

　　2.复制算法（Java堆中新生代的垃圾回收算法）

此GC算法实际上解决了标记-清除算法带来的“内存碎片化”问题。首先还是先标记处待回收内存和不用回收的内存，下一步将不用回收的内存复制到新的内存区域，这样旧的内存区域就可以全部回收，而新的内存区域则是连续的。它的缺点就是会损失掉部分系统内存，因为你总要腾出一部分内存用于复制。

　　在上文《JVM入门——运行时数据区》提到过在Java堆中被分为了新生代和老年代，这样的划分是方便GC。Java堆中的新生代就使用了GC复制算法。在新生代中又分为了三个区域：Eden 空间、To Survivor空间、From Survivor空间。不妨将注意力回到这张图的左边新生代部分：

　　新的对象实例被创建的时候通常在Eden空间，发生在Eden空间上的GC称为Minor GC，当在新生代发生一次GC后，会将Eden和其中一个Survivor空间的内存复制到另外一个Survivor中，如果反复几次有对象一直存活，此时内存对象将会被移至老年代。可以看到新生代中Eden占了大部分，而两个Survivor实际上占了很小一部分。这是因为大部分的对象被创建过后很快就会被GC（这里也许运用了是二八原则）。

　　3.标记-压缩算法（或称为标记-整理算法，Java堆中老年代的垃圾回收算法）

　　对于新生代，大部分对象都不会存活，所以在新生代中使用复制算法较为高效，而对于老年代来讲，大部分对象可能会继续存活下去，如果此时还是利用复制算法，效率则会降低。标记-压缩算法首先还是“标记”，标记过后，将不用回收的内存对象压缩到内存一端，此时即可直接清除边界处的内存，这样就能避免复制算法带来的效率问题，同时也能避免内存碎片化的问题。老年代的垃圾回收称为“Major GC”。

开发中常用的git命令：

    查看有变动的文件

    git status

    将当前目录下所有有变化目录进行添加

    git add .

    将添加的变动提交到本地仓库，提交后git status将看不到有变化文件啦

    git commit  -m 'mengshanshan update'

    将git上最新代码拉到本地

    git pull origin master

    将本地仓库代码提交到master

    git push origin master

    将本地仓库代码提交到master的streaming分支，页面可以替交merge

    git push origin master:streaming

    退回到上一版本

    git reset —hard  

5. maven命令：

    下载本地依赖:

    mvn -DskipTests clean package install

    下载缺失包：

     mvn compile

    下载编译项目

    mvn clean && mvn install -U

    生成lib目录，将相关包移进lib下

    mvn dependency:copy-dependencies -DoutputDirectory=lib

    tar包:

    mvn assembly:assembly -DskipTests -P{p}

    class包，产生class等，部署项目使用~

    mvn -DskipTests -Pcdn_online clean package

    查找依赖

    mvn dependency:tree

把商品数量存入redis中，当某一个用户购买成功后，同步缓存，数量就为0，别的用户就不能购买。

1：读取数据的时候先从redis里面查，若没有，再去数据库查，同时写到redis里面，并且要设置失效时间。
2：存数据的时候要具体情况具体分析，可以选择同时插到数据库和redis（要是存放到redis中，最好设置失效时间），也可以选择直接插到数据库里面，少考虑一些问题。

Junit

·@Before

       public void befores(){

              System.out.println("前--");

       }

       @Test

       public void test1(){

              System.out.println("中间--");

       }

       @After

       public void afters(){

              System.out.println("后--");

       }

jMeter详解：

https://blog.csdn.net/jek123456/article/details/79027037

requestBody详解

https://www.cnblogs.com/qiankun-site/p/5774300.html

实现方式共有两种：编码方式；声明式事务管理方式。

基于AOP技术实现的声明式事务管理，实质就是：在方法执行前后进行拦截，然后在目标方法开始之前创建并加入事务，执行完目标方法后根据执行情况提交或回滚事务。

声明式事务管理又有两种方式：基于XML配置文件的方式；另一个是在业务方法上进行@Transactional注解，将事务规则应用到业务逻辑中。

事务的4个特性：

• 原子性：一个事务中所有对数据库的操作是一个不可分割的操作序列，要么全做，要么全部做。
• 一致性：数据不会因为事务的执行而遭到破坏。
• 隔离性：一个事务的执行，不受其他事务（进程）的干扰。既并发执行的个事务之间互不干扰。
• 持久性：一个事务一旦提交，它对数据库的改变将是永久的。

https://www.cnblogs.com/Dylansuns/archive/2017/04/30/6789161.html

http://www.cnblogs.com/xwdreamer/archive/2012/04/01/2428857.html

https://blog.csdn.net/zlfprogram/article/details/74066841

1. 速度更快 – 红黑树
2. 代码更少 – Lambda
3. 强大的Stream API – Stream
4. 便于并行 – Parallel
5. 最大化减少空指针异常 – Optional

在ConcurrentHashMap中，无论是读操作还是写操作都能保证很高的性能：在进行读操作时(几乎)不需要加锁，而在写操作时通过锁分段技术只对所操作的段加锁而不影响客户端对其它段的访问。特别地，在理想状态下，ConcurrentHashMap 可以支持 16 个线程执行并发写操作（如果并发级别设为16），及任意数量线程的读操作。

ConcurrentHashMap本质上是一个Segment数组，而一个Segment实例又包含若干个桶，每个桶中都包含一条由若干个 HashEntry 对象链接起来的链表。总的来说，ConcurrentHashMap的高效并发机制是通过以下三方面来保证的(具体细节见后文阐述)：

通过锁分段技术保证并发环境下的写操作；

通过 HashEntry的不变性、Volatile变量的内存可见性和加锁重读机制保证高效、安全的读操作；

通过不加锁和加锁两种方案控制跨段操作的的安全性。

springAop：

实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。

springIoc的实现原理：

反射与工厂模式

2.1 开发方面

        在项目开发过程当中，就速度而言：

            hibernate开发中，sql语句已经被封装，直接可以使用，加快系统开发；

            Mybatis 属于半自动化，sql需要手工完成，稍微繁琐；

        但是，凡事都不是绝对的，如果对于庞大复杂的系统项目来说，发杂语句较多，选择hibernate 就不是一个好方案。

    2.2 sql优化方面

        Hibernate 自动生成sql,有些语句较为繁琐，会多消耗一些性能；

        Mybatis 手动编写sql，可以避免不需要的查询，提高系统性能；

    2.3 对象管理比对

        Hibernate 是完整的对象-关系映射的框架，开发工程中，无需过多关注底层实现，只要去管理对象即可；

        Mybatis 需要自行管理 映射关系；

    2.4 缓存方面    

比较：

          Hibernate 具有良好的管理机制，用户不需要关注SQL，如果二级缓存出现脏数据，系统会保存，；

           Mybatis 在使用的时候要谨慎，避免缓存CAche 的使用。

区别1：

Struts2 的核心是基于一个Filter即StrutsPreparedAndExcuteFilter

SpringMvc的核心是基于一个Servlet即DispatcherServlet(前端控制器)

区别2：

Struts2是基于类开发的，传递的参数是通过类的属性传递(属性驱动和模型驱动),所以只能设计成多例prototype

SpringMvc是基于类中的方法开发的，也就是一个url对应一个方法，传递参数是传到方法的形参上面，所以既可以是单例模式也可以是多例模式singiton

区别3：

Struts2采用的是值栈存储请求以及响应数据，OGNL存取数据

SpringMvc采用request来解析请求内容，然后由其内部的getParameter给方法中形参赋值，再把后台处理过的数据通过ModelAndView对象存储，Model存储数据，View存储返回的页面，再把对象通过request传输到页面去。

---------------------

作者：爪哇小明

来源：CSDN

原文：https://blog.csdn.net/weixin_38429587/article/details/79050550?utm_source=copy

版权声明：本文为博主原创文章，转载请附上博文链接！

1、pageContext 表示页容器 –>EL、标签、上传
2、request 服务器端取得客户端的信息：头信息、Cookie、请求参数、MVC设计模式
3、response 服务器端回应给客户端信息：Cookie、重定向
4、session 表示每一个用户，用于登录验证上
5、application 表示整个服务器，getRealPath()
6、config 去的初始化参数，初始化参数在web.xml中配置
7、exception 表示的是错误页的处理操作
8、page 如同this一样，表示整个JSP页面
9、out 输出，但是尽量使用表达式输出

https://www.cnblogs.com/wangyaning/p/3740899.html

软件复用是指在构造新的软件系统的过程中，对已存在的软件人工制品的使用技术。
如果是在一个系统中多次使用一个相同的软件成分，这叫软件共享。
对一个软件进行修改，使它能运行于新的软、硬件平台这称作软件移植。

init()：在Servlet实例化后，Servlet容器会调用init()方法，来初始化该对象，主要是为了让Servlet对象在处理客户请求前可以完成一些初始化的工作。例如：建立数据库连接，获取配置信息等。对于每一个Servlet实例，init()方法只能被调用一次。init()方法有一个类型为ServletConfig的参数，Servlet容器通过这个参数向Servlet传递配置信息。Servlet使用ServletConfig对象从Web应用程序的配置信息中获取以名-值对形式提供的初始化参数。另外，在Servlet中，还可以通过ServletConfig对象获取描述Servlet运行环境的ServletContext对象，使用该对象，Servlet可以和它的Servlet容器进行通信。

service():容器调用service()方法来处理客户端的请求。要注意的是，在service()方法被容器调用之前，必须确保init()方法正确完成。容器会构造一个表示客户端请求信息的请求对象(类型为ServletRequest)和一个用于对客户端进行响应的响应对象(类型为ServletResponse)作为参数传递给service()方法。在service()方法中，Servlet对象通过ServletRequest对象得到客户端的相关信息和请求信息，在对请求进行处理后，调用ServletResponse对象的方法设置响应信息。

destroy():当容器检测到一个Servlet对象应该从服务中被移除的时候，容器会调用该对象的destroy()方法，以便让Servlet对象可以释放它所使用的资源，保存数据到持久存储设备中。例如：将内存中的数据保存到数据库中，关闭数据库的连接等。当需要释放内存或容器关闭时，容器就会调用Servlet对象的destroy()方法。在Servlet容器调用destroy()方法前，如果还有其他的线程正在service()方法中执行，容器会等待这些线程执行完毕或等待服务器设定的超时值到达。一旦Servlet对象的destroy()方法被调用，容器不会再把其他的请求发送给该对象。如果需要该Servlet再次为客户端服务，容器会重新产生一个Servlet对象来处理客户端的请求。在destroy()方法调用后，容器会释放这个Servlet对象，在随后的时候内，该对象会被Java的垃圾收集器所回收。

getServletConfig():该方法返回容器调用init()方法时传递给Servlet对象的ServletConfig对象，ServletConfig对象包含了Servlet的初始化参数。

getServletInfo():返回一个String类型的字符串，其中包括了关于Servlet的信息，例如，作者、版本和版权。该方法返回的应该是纯文本字符串，而不是任何类型的标记(HTML,XML等)。

1、客户端发起请求、前端控制器统一（org.springframework.web.servlet.DispatcherServlet）进行拦截。调用其中的doService(..)方法。再调用其中的doDispatch(..)方法

2、根据请求查询请求的处理器映射器。返回HandlerExecutionChain处理器执行链。

mappedHandler = getHandler(processedRequest, false);

3、获取处理器适配器。

HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

4、由获取到的处理器适配器执行处理器方法。

mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

5、处理器执行完成后返回modelAndView

6、将modelandview 传递给视图解析器。进行数据绑定。

7、响应给客户端

https://www.cnblogs.com/zhujiabin/p/5498272.html

"xml": 返回 XML 文档，可用 jQuery 处理。"html": 返回纯文本 HTML 信息；包含的 script 标签会在插入 dom 时执行。"script": 返回纯文本 JavaScript 代码。不会自动缓存结果。除非设置了 "cache" 参数。注意：在远程请求时(不在同一个域下)，所有 POST 请求都将转为 GET 请求。（因为将使用 DOM 的 script标签来加载）"json": 返回 JSON 数据 。"jsonp": JSONP 格式。使用 JSONP 形式调用函数时，如 "myurl?callback=?" jQuery 将自动替换 ? 为正确的函数名，以执行回调函数。"text": 返回纯文本字符串

事务

缓存

异常

日志

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

public class CacheDemo

{

    public object GetCacheDataList()

        {

            const int cacheTime = 60;   

            const string lockKey = cacheKey;

            const string cacheKey = "datainfolist";      

            var cacheValue = CacheHelper.Get(cacheKey);

            if (cacheValue != null)

            {

                return cacheValue;

            }

            else

            {

                lock (lockKey)

                {

                    cacheValue = CacheHelper.Get(cacheKey);

                    if (cacheValue != null)

                    {

                        return cacheValue;

                    }

                    else

                    {

                        cacheValue = GetDataBaseInfo();              

                        CacheHelper.Add(cacheKey, cacheValue, cacheTime);

                    }                   

                }

                return cacheValue;

            }

        }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

public object GetProductListNew()

        {

            const int cacheTime = 30;

            const string cacheKey = "product_list";

            //缓存标记。

            const string cacheSign = cacheKey + "_sign";

            var sign = CacheHelper.Get(cacheSign);

            //获取缓存值

            var cacheValue = CacheHelper.Get(cacheKey);

            if (sign != null)

            {

                return cacheValue; //未过期，直接返回。

            }

            else

            {

                CacheHelper.Add(cacheSign, "1", cacheTime);

                ThreadPool.QueueUserWorkItem((arg) =>

                {

                    cacheValue = GetProductListFromDB(); //这里一般是 sql查询数据。

                    CacheHelper.Add(cacheKey, cacheValue, cacheTime*2); //日期设缓存时间的2倍，用于脏读。               

                });

                return cacheValue;

            }

        }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

public object GetProductListNew()

        {

            const int cacheTime = 30;

            const string cacheKey = "product_list";

            var cacheValue = CacheHelper.Get(cacheKey);

            if (cacheValue != null)

                return cacheValue;

            cacheValue = CacheHelper.Get(cacheKey);

            if (cacheValue != null)

            {

                return cacheValue;

            }

            else

            {

                cacheValue = GetProductListFromDB(); //数据库查询不到，为空。

                if (cacheValue == null)

                {

                    cacheValue = string.Empty; //如果发现为空，设置个默认值，也缓存起来。               

                }

                CacheHelper.Add(cacheKey, cacheValue, cacheTime);

                return cacheValue;

            }

        }

1

2

3

4

Map<Integer, Integer> map = new HashMap<Integer, Integer>();

for (Map.Entry<Integer, Integer> entry : map.entrySet()) {

  System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());

}

1

2

3

4

5

6

7

8

9

Map<Integer, Integer> map = new HashMap<Integer, Integer>();

//遍历map中的键

for (Integer key : map.keySet()) {

  System.out.println("Key = " + key);

}

//遍历map中的值

for (Integer value : map.values()) {

  System.out.println("Value = " + value);

}

1

2

@Autowired()@Qualifier("baseDao")

privateBaseDao baseDao;

1

2

@Resource(name="baseDao")

privateBaseDao baseDao;