Java最常见的面试题--2

设计模式

83.有哪些熟悉的设计模式？

单例模式

某个类的实例对象只有一个，你没有办法去new，因为构造器是被private修饰的，一般通过getInstance()的方法来获取它们的实例。getInstance()的返回值是一个对象的引用，并不是一个新的实例

public class Singleton(单例模式) {  
    private static Singleton instance;  
    private Singleton (){}  //构造函数
    public static synchronized Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
    return instance;  
    }  
} 
//synchronized 是同步锁

观察者模式

举个栗子：假设有三个人，小美（女，22），小王和小李。小美很漂亮，小王和小李是两个程序猿，时刻关注着小美的一举一动。有一天，小美说了一句：“谁来陪我打游戏啊。”这句话被小王和小李听到了，结果乐坏了，蹭蹭蹭，没一会儿，小王就冲到小美家门口了，在这里，小美是被观察者，小王和小李是观察者，被观察者发出一条信息，然后观察者们进行相应的处理

看代码

定义一个接口，它有一个函数
public interface Person {//(相当于一个进群规则)
   //小王和小李通过这个接口可以接收到小美发过来的消息
   void getMessage(String s);
}

这个接口相当于一个进群规则，只有Person才能进群，小美发送通知的时候就会在这个群里发消息，在这个群里面的人都会收到消息。

public class LaoWang implements Person {

   private String name = "小王";

   public LaoWang() {
   }

   @Override
   public void getMessage(String s) { 
       System.out.println(name + "接到了小美打过来的电话，电话内容是：" + s);
   }

}

public class LaoLi implements Person {

   private String name = "小李";

   public LaoLi() {
   }

   @Override
   public void getMessage(String s) {
       System.out.println(name + "接到了小美打过来的电话，电话内容是：->" + s);
   }
}

再看看小美的代码：

public class XiaoMei {
//这个list相当于一个群，注意这个群有一个规则，就是具有getMessage的才能进来
   List list = new ArrayList();
    public XiaoMei(){
    }
//把某个人(这个人必须满足进群规则，就是继承Person)拉进群里
    public void addPerson(Person person){
        list.add(person);
    }

    //遍历list，把自己的通知发送给所有群里的人
    public void notifyPerson() {
        for(Person person:list){
            person.getMessage("你们过来吧，谁先过来谁就能陪我一起玩儿游戏!");
        }
    }
}

我们写一个测试类来看一下结果对不对

public class Test {
   public static void main(String[] args) {

       XiaoMei xiao_mei = new XiaoMei();
       LaoWang lao_wang = new LaoWang();
       LaoLi lao_li = new LaoLi();

       //小王和小李被小美拉进群
       xiao_mei.addPerson(lao_wang);
       xiao_mei.addPerson(lao_li);

       //小美在群里发通知
       xiao_mei.notifyPerson();
   }
}

装饰者模式 对已有的业务逻辑进一步的封装，使其增加额外的功能

举个栗子，我想吃三明治，首先我需要一根大大的香肠，然后我喜欢吃奶油，在香肠上面加一点奶油，然后需要再放一点蔬菜，最后再用两片面包把它包裹起来，形成一个三明治。

首先，我们需要写一个Food类，让其他所有食物都来继承这个类

public class Food {

   private String food_name;

   public Food() {
   }

   public Food(String food_name) {
       this.food_name = food_name;
   }

   public String make() {
       return food_name;
   };
}

然后我们写几个子类继承它
构造方法传入一个Food类型的参数，然后在make方法中加入一些自己的逻辑

//面包类
public class Bread extends Food {

   private Food basic_food;

   public Bread(Food basic_food) {
       this.basic_food = basic_food;
   }

   public String make() {
       return basic_food.make()+"+面包";
   }
}

//奶油类
public class Cream extends Food {

   private Food basic_food;

   public Cream(Food basic_food) {
       this.basic_food = basic_food;
   }

   public String make() {
       return basic_food.make()+"+奶油";
   }
}

//蔬菜类
public class Vegetable extends Food {

   private Food basic_food;

   public Vegetable(Food basic_food) {
       this.basic_food = basic_food;
   }

   public String make() {
       return basic_food.make()+"+蔬菜";
   }

}

Test类

public class Test {
   public static void main(String[] args) {
       Food food = new Bread(new Vegetable(new Cream(new Food("香肠"))));
       System.out.println(food.make());
   }
}

看到没有，一层一层封装，我们从里往外看：最里面我new了一个香肠，在香肠的外面我包裹了一层奶油，在奶油的外面我又加了一层蔬菜，最外面我放的是面包

运行结果

适配器模式 将两种完全不同的事物联系到一起，就像现实生活中的变压器

假设一个手机充电器需要的电压是20V，但是正常的电压是220V，这时候就需要一个变压器，将220V的电压转换成20V的电压，这样，变压器就将20V的电压和手机联系起来了。

public class Test {
    public static void main(String[] args) {
        Phone phone = new Phone();//定义一个手机
        VoltageAdapter adapter = new VoltageAdapter();//定义一个适配器
        phone.setAdapter(adapter);//手机装上适配器
        phone.charge();//手机充电
    }
}

// 手机类
class Phone {

    public static final int V = 220;// 正常电压220v，是一个常量

    private VoltageAdapter adapter;

    // 充电
    public void charge() {
        adapter.changeVoltage();
    }

    public void setAdapter(VoltageAdapter adapter) {
        this.adapter = adapter;
    }
}

// 变压器
class VoltageAdapter {
    // 改变电压的功能
    public void changeVoltage() {
        System.out.println("正在充电...");
        System.out.println("原始电压：" + Phone.V + "V");
        System.out.println("经过变压器转换之后的电压:" + (Phone.V - 200) + "V");
    }
}

运行结果

工厂模式

简单工厂模式：1.一个抽象的接口，2.多个抽象接口的实现类，3.一个工厂类，用来实例化抽象的接口

一个抽象的接口

// 抽象产品类
abstract class Car {
    public void run();//能跑
    public void stop();//能停
}

多个抽象接口的实现类

// 具体实现类
class Benz implements Car {
    public void run() {
        System.out.println("Benz开始启动了。。。。。");
    }

    public void stop() {
        System.out.println("Benz停车了。。。。。");
    }
}

class Ford implements Car {
    public void run() {
        System.out.println("Ford开始启动了。。。");
    }

    public void stop() {
        System.out.println("Ford停车了。。。。");
    }
}

一个工厂类

// 工厂类
class Factory {
    public static Car getCarInstance(String type) {
        Car c = null;
        if ("Benz".equals(type)) {
            c = new Benz();
        }
        if ("Ford".equals(type)) {
            c = new Ford();
        }
        return c;
    }
}

测试类

public class Test {

   public static void main(String[] args) {
       Car c = Factory.getCarInstance("Benz");
       if (c != null) {
           c.run();
           c.stop();
       } else {
           System.out.println("造不了这种汽车。。。");
       }

   }

}

代理模式

举个栗子：打官司，律师就代理你进行辩论；开庭前（编译期间）你花钱请了一个有名的律师，他就是静态代练，你没钱，开庭的时候（运行期间）。法院随机给你找一个律师，这就是动态代理。

84.简单工厂和抽象工厂有什么区别？

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类
一个抽象工厂类，可以派生出多个具体工厂类
每个具体工厂类可以创建多个具体产品类的实例

Spring / Spring MVC

85.为什么要使用 spring?
简介：Spring是一个轻量级的控制反转(IOC)和面向切面(AOP)的容器框架
目的：解决企业应用开发的复杂性
86.解释一下什么是 aop？

AOP（Aspect-Oriented Programming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善

目的：当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。
操作：将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。简单来说：将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。比如权限认证、日志、事务处理。
87.解释一下什么是 ioc？
翻译：控制反转
解释：借助于“第三方”实现具有依赖关系的对象之间的解耦

全部对象的控制权全部上缴给“第三方”IOC容器，所以，IOC容器成了整个系统的关键核心，它起到了一种类似“粘合剂”的作用
为何叫控制反转

去掉IOC

软件系统在没有引入IOC容器之前，对象A依赖于对象B，那么对象A在初始化或者运行到某一点的时候，
自己必须主动去创建对象B或者使用已经创建的对象B。无论是创建还是使用对象B，控制权都在自己手上。

软件系统在引入IOC容器之后，这种情形就完全改变了，，由于IOC容器的加入，对象A与对象B之间失去了直接联系，
所以，当对象A运行到需要对象B的时候，IOC容器会主动创建一个对象B注入到对象A需要的地方。
对象A获得依赖对象B的过程,由主动行为变为了被动行为，控制权颠倒过来了，
这就是“控制反转”这个名称的由来。

88.spring 常用的注入方式有哪些？
a.构造方法注入
b.setter注入
c.基于注解的注入
声明一个简单的bean

public class Roles {
    private int id;
    private String roleName;
    public Roles() {
    }
    public Roles(int id,String roleName) {
        this.id=id;
        this.roleName = roleName;
    }
}

构造方法注入

setter注入我们能发现构造器 set注入是

测试main方法

public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        Roles r=(Roles)context.getBean("roles");
        System.out.println(r.toString());
    }

基于注解的注入

Autowired是自动注入，自动从spring的上下文找到合适的bean来注入
Resource用来指定名称注入
Qualifier和Autowired配合使用，指定bean的名称，如
    @Autowired
    @Qualifier("userDAO")
    private UserDAO userDAO;

89.spring 中的 bean 是线程安全的吗？
容器本身并没有提供Bean的线程安全策略
90.spring 支持几种 bean 的作用域？
singleton：单例模式，在整个Spring IoC容器中，使用singleton定义的Bean将只有一个实例

prototype：原型模式，每次通过容器的getBean方法获取prototype定义的Bean时，都将产生一个新的Bean实例

request：对于每次HTTP请求，使用request定义的Bean都将产生一个新实例，即每次HTTP请求将会产生不同的Bean实例。只有在Web应用中使用Spring时，该作用域才有效

session：对于每次HTTP Session，使用session定义的Bean都将产生一个新实例。同样只有在Web应用中使用Spring时，该作用域才有效

globalsession：每个全局的HTTP Session，使用session定义的Bean都将产生一个新实例。典型情况下，仅在使用portlet context的时候有效。同样只有在Web应用中使用Spring时，该作用域才有效
91.spring 自动装配 bean 有哪些方式？
1.在XML中进行显式配置
2.在Java中进行显式配置
3.隐式的bean发现机制和自动装配
92.spring 事务实现方式有哪些？
含义:事务是逻辑上的一组操作，要么都执行，要么都不执行
事物的特性（ACID）：

事务的特性

原子性：事务是最小的执行单位，不允许分割。事务的原子性确保动作要么全部完成，要么完全不起作用；
一致性：执行事务前后，数据保持一致；
隔离性：并发访问数据库时，一个用户的事物不被其他事物所干扰，各并发事务之间数据库是独立的；
持久性: 一个事务被提交之后。它对数据库中数据的改变是持久的，即使数据库发生故障也不应该对其有任何影响
来源https://juejin.im/post/5b00c52ef265da0b95276091

1.编程式事务管理对基于 POJO (通指没有使用Entity Beans的普通java对象)的应用来说是唯一选择。我们需要在代码中调用beginTransaction()、commit()、rollback()等事务管理相关的方法，这就是编程式事务管理。
2.基于 TransactionProxyFactoryBean 的声明式事务管理
3.基于 @Transactional 的声明式事务管理
4.基于 Aspectj AOP 配置事务
93.说一下 spring 的事务隔离？
事务隔离级别指的是一个事务对数据的修改与另一个并行的事务的隔离程度，当多个事务同时访问相同数据时，如果没有采取必要的隔离机制，就可能发生以下问题：

脏读（Dirty read）: 当一个事务正在访问数据并且对数据进行了修改，而这种修改还没有提交到数据库中，这时另外一个事务也访问了这个数据，然后使用了这个数据。因为这个数据是还没有提交的数据，那么另外一个事务读到的这个数据是“脏数据”，依据“脏数据”所做的操作可能是不正确的。
丢失修改（Lost to modify）: 指在一个事务读取一个数据时，另外一个事务也访问了该数据，那么在第一个事务中修改了这个数据后，第二个事务也修改了这个数据。这样第一个事务内的修改结果就被丢失，因此称为丢失修改。
例如：事务1读取某表中的数据A=20，事务2也读取A=20，事务1修改A=A-1，事务2也修改A=A-1，最终结果A=19，事务1的修改被丢失。
不可重复读（Unrepeatableread）: 指在一个事务内多次读同一数据。在这个事务还没有结束时，另一个事务也访问该数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改导致第一个事务两次读取的数据可能不太一样。这就发生了在一个事务内两次读到的数据是不一样的情况，因此称为不可重复读。
幻读（Phantom read）: 幻读与不可重复读类似。它发生在一个事务（T1）读取了几行数据，接着另一个并发事务（T2）插入了一些数据时。在随后的查询中，第一个事务（T1）就会发现多了一些原本不存在的记录，就好像发生了幻觉一样，所以称为幻读。

不可重复度和幻读区别：
不可重复读的重点是修改，幻读的重点在于新增或者删除。
例1（同样的条件, 你读取过的数据, 再次读取出来发现值不一样了）：事务1中的A先生读取自己的工资为 1000的操作还没完成，事务2中的B先生就修改了A的工资为2000，导致A再读自己的工资时工资变为 2000；这就是不可重复读。
例2（同样的条件, 第1次和第2次读出来的记录数不一样）：假某工资单表中工资大于3000的有4人，事务1读取了所有工资大于3000的人，共查到4条记录，这时事务2 又插入了一条工资大于3000的记录，事务1再次读取时查到的记录就变为了5条，这样就导致了幻读。
94.说一下 spring mvc 运行流程？
Spring运行流程描述：

用户向服务器发送请求，请求被Spring 前端控制Servelt DispatcherServlet捕获；
DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI）。然后根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain对象的形式返回；
DispatcherServlet 根据获得的Handler，选择一个合适的HandlerAdapter；（附注：如果成功获得HandlerAdapter后，此时将开始执行拦截器的preHandler(...)方法）
提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)。在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：
HttpMessageConveter：将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息
数据转换：对请求消息进行数据转换。如String转换成Integer、Double等
数据根式化：对请求消息进行数据格式化。如将字符串转换成格式化数字或格式化日期等
数据验证：验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中
Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象；
根据返回的ModelAndView，选择一个适合的ViewResolver（必须是已经注册到Spring容器中的ViewResolver)返回给DispatcherServlet ；
ViewResolver 结合Model和View，来渲染视图；
将渲染结果返回给客户端。

95.spring mvc 有哪些组件？
Spring MVC的核心组件：
DispatcherServlet：中央控制器，把请求给转发到具体的控制类
Controller：具体处理请求的控制器
HandlerMapping：映射处理器，负责映射中央处理器转发给controller时的映射策略
ModelAndView：服务层返回的数据和视图层的封装类
ViewResolver：视图解析器，解析具体的视图
Interceptors ：拦截器，负责拦截我们定义的请求然后做处理工作
96. @RequestMapping 的作用是什么？
RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
RequestMapping注解有六个属性，下面我们把她分成三类进行说明。

value， method：
value：指定请求的实际地址
method：指定请求的method类型， GET、POST、PUT、DELETE等；
consumes，produces
consumes：指定处理请求的提交内容类型（Content-Type），例如
application/json, text/html；
produces：指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回；
params，headers
params：指定request中必须包含某些参数值是，才让该方法处理。
headers：指定request中必须包含某些指定的header值，才能让该方法处理请求。

Spring Boot / Spring Cloud

97.什么是 spring boot？
简化了Spring众多框架中所需的大量且繁琐的配置文件，所以 SpringBoot是一个服务于框架的框架，服务范围是简化配置文件。

why?
Spring Boot使编码变简单
Spring Boot使配置变简单
Spring Boot使部署变简单
Spring Boot使监控变简单
Spring的不足

98. spring boot 核心配置文件是什么？
Spring Boot提供了两种常用的配置文件：
properties文件
相对于properties文件而言，yml文件更年轻，也有很多的坑。可谓成也萧何败萧何，yml通过空格来确定层级关系，使配置文件结构跟清晰，但也会因为微不足道的空格而破坏了层级关系。
99.spring boot 有哪些方式可以实现热部署？
①. 使用spring loaded**
在项目配置文件中添加如下代码：


        
            
                
                org.springframework.boot
                spring-boot-maven-plugin
                
                    
                    
                    
                        org.springframework
                        springloaded
                        1.2.6.RELEASE

添加完毕后需要使用mvn指令运行：
首先找到IDEA中的Edit configurations ,然后进行如下操作：（点击左上角的"+",然后选择maven将出现右侧面板，在红色划线部位输入如图所示指令，你可以为该指令命名(此处命名为MvnSpringBootRun)）

点击保存将会在IDEA项目运行部位出现，点击绿色箭头运行即可

image

②. 使用spring-boot-devtools
在项目的pom文件中添加依赖：

 
 
     org.springframework.boot
     spring-boot-devtools

然后：使用 shift+ctrl+alt+"/" （IDEA中的快捷键）选择"Registry" 然后勾选 compiler.automake.allow.when.app.running
100.jpa 和 hibernate 有什么区别？

JPA和Hibernate之间的关系，可以简单的理解为JPA是标准接口，Hibernate是实现。那么Hibernate是如何实现与JPA的这种关系的呢。Hibernate主要是通过三个组件来实现的，及hibernate-annotation、hibernate-entitymanager和hibernate-core。

hibernate-annotation是Hibernate支持annotation方式配置的基础，它包括了标准的JPA annotation以及Hibernate自身特殊功能的annotation。
hibernate-core是Hibernate的核心实现，提供了Hibernate所有的核心功能。
hibernate-entitymanager实现了标准的JPA，可以把它看成hibernate-core和JPA之间的适配器，它并不直接提供ORM的功能，而是对hibernate-core进行封装，使得Hibernate符合JPA的规范。

101.什么是 spring cloud
从字面理解，Spring Cloud 就是致力于分布式系统、云服务的框架。
Spring Cloud 为开发人员提供了快速构建分布式系统中一些常见模式的工具，例如：
配置管理
服务注册与发现
断路器
智能路由
服务间调用
负载均衡
微代理
控制总线
一次性令牌
全局锁
领导选举
分布式会话
集群状态
分布式消息
……

使用 Spring Cloud 开发人员可以开箱即用的实现这些模式的服务和应用程序。这些服务可以任何环境下运行，包括分布式环境，也包括开发人员自己的笔记本电脑以及各种托管平台。
一个认识spring cloud的项目（来源网络...）
https://pan.baidu.com/s/1i7lFCPn
102. spring cloud 断路器的作用是什么？
在Spring Cloud中使用了Hystrix 来实现断路器的功能，断路器可以防止一个应用程序多次试图执行一个操作，即很可能失败，允许它继续而不等待故障恢复或者浪费 CPU 周期，而它确定该故障是持久的。断路器模式也使应用程序能够检测故障是否已经解决，如果问题似乎已经得到纠正，应用程序可以尝试调用操作。

断路器增加了稳定性和灵活性，以一个系统，提供稳定性，而系统从故障中恢复，并尽量减少此故障的对性能的影响。它可以帮助快速地拒绝一个操作，即很可能失败的操作，而不是等待操作超时（或者不返回）的请求，以保持系统的响应时间。如果断路器提高每次改变状态的时间的事件，该信息可以被用来监测由断路器保护系统的部件的健康状况，或以提醒管理员当断路器跳闸，以在打开状态。
103.spring cloud 的核心组件有哪些？
①. 服务发现——Netflix Eureka
一个RESTful服务，用来定位运行在AWS地区（Region）中的中间层服务。由两个组件组成：Eureka服务器和Eureka客户端。Eureka服务器用作服务注册服务器。Eureka客户端是一个java客户端，用来简化与服务器的交互、作为轮询负载均衡器，并提供服务的故障切换支持。Netflix在其生产环境中使用的是另外的客户端，它提供基于流量、资源利用率以及出错状态的加权负载均衡。
②. 客服端负载均衡——Netflix Ribbon
Ribbon，主要提供客户侧的软件负载均衡算法。Ribbon客户端组件提供一系列完善的配置选项，比如连接超时、重试、重试算法等。Ribbon内置可插拔、可定制的负载均衡组件。
③. 断路器——Netflix Hystrix
断路器可以防止一个应用程序多次试图执行一个操作，即很可能失败，允许它继续而不等待故障恢复或者浪费 CPU 周期，而它确定该故障是持久的。断路器模式也使应用程序能够检测故障是否已经解决。如果问题似乎已经得到纠正，应用程序可以尝试调用操作。
④. 服务网关——Netflix Zuul
类似nginx，反向代理的功能，不过netflix自己增加了一些配合其他组件的特性。
⑤. 分布式配置——Spring Cloud Config
这个还是静态的，得配合Spring Cloud Bus实现动态的配置更新。

Hibernate

104.为什么要使用 hibernate？
对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM(对象关系映射)实现。他很大程度的简化DAO层的编码工作

hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。

hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。
105.什么是 ORM 框架？
对象-关系映射（Object-Relational Mapping，简称ORM）面向对象的开发方法是当今企业级应用开发环境中的主流开发方法，关系数据库是企业级应用环境中永久存放数据的主流数据存储系统。对象和关系数据是业务实体的两种表现形式，业务实体在内存中表现为对象，在数据库中表现为关系数据。内存中的对象之间存在关联和继承关系，而在数据库中，关系数据无法直接表达多对多关联和继承关系。因此，对象-关系映射(ORM)系统一般以中间件的形式存在，主要实现程序对象到关系数据库数据的映射。
106.hibernate 中如何在控制台查看打印的 sql 语句？

spring.jpa.properties.hibernate.show_sql=true          //控制台是否打印
spring.jpa.properties.hibernate.format_sql=true        //格式化sql语句
spring.jpa.properties.hibernate.use_sql_comments=true  //指出是什么操作生成了该语句

107.hibernate 有几种查询方式？
1.hql查询

HQL是面向对象查询操作的

hql查询，sql查询，条件查询

Query query = session.createQuery("from Customer where name = ?");
query.setParameter(0, "苍老师");
Query.list();

2.sql查询

SQL是结构化查询语言 是面向数据库表结构的

SQLQuery query = session.createSQLQuery("select * from customer");
List list = query.list();

3.条件查询

查询所有    session.creartCriteria(实体对象.class)
=======================================================
案例是:
/ 获得session对象
 Session session = HibernateUtils.openSession();
 // 通过session获得查询对象 criteria
 Criteria criteria = session.createCriteria(Customer.class); // 括号里面的参数就是查询条件了,表示我们查询的就是这个实体对象.
 List list = criteria.list(); // 这表示接收返回值.
 // 遍历打印结果
 for (Customer customer : list) {
 System.out.println(customer);
 }
 }

查询单个字段 
======================================================
案例是:
Session session = HibernateUtils.openSession();
 // 通过session获得查询对象 criteria
 Criteria criteria = session.createCriteria(Customer.class); // 括号里面的参数就是查询条件了,表示我们查询的就是这个实体对象.
 // 赋值我们需要查询的实体的变量名(也就是需要查询的字段名)
 criteria.setProjection(Projections.property("cust_name"));// Projection 投影的意思. 
 // 查询后返回的就是Object
 List

Java最常见的面试题--2

设计模式

Spring / Spring MVC

Spring Boot / Spring Cloud

Hibernate

Mybatis

Kafka

kafka的工作流程

消息队列之 RabbitMQ

声明

你可能感兴趣的:(Java最常见的面试题--2)