java面试干货

迷南。 2023-08-17 17:23 88阅读 0赞

**一、mybatis和hibernate有什么不同**

首先无论是mybatis还是hibernate都是通过配置文件，将数据库的表pojo映射起来的。mybatis和hibernate都可以称为ORM（对象关系映射）框架，只是hibernate是完全面向pojo的，而mybatis则不是，hibernate基本不需要编写sql就可以通过映射关系来操作数据库，是一种全表映射的体现，而mybatis则不同，它需要我们提供sql去运行。由于hibernate无须sql，当多表关联超过三个的时候，通过hibernate的级联会造成太多性能的丢失，而且如果查询语句中的子段是根据特定的条件变化的，而hibernate就无法支持这样的变化。

**1.hibernate**

首先通过hibernate的映射文件，将数据库中的表和pojo映射起来，然后通过对pojo操作，从而影响数据库的表。有自己的hql语句，提高效率

**2.mybatis**

首先mybatis提供了使用Mapper的接口编程，只要一个接口和一个xml就能创建映射。mybatis可以自由的书写sql，支持动态的sql，处理列表，动态的生成表名，支持存储过程，这样就可以灵活的定义查询语句，满足各类需求和性能优化的需求，缺点是工作量稍微大于hibernate。

**二、java中的设计模式**

Java 中一般认为有**23**种设计模式   
　　总体来说设计模式分为三大类：   
　　　　**创建型模式**，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。   
　　　　**结构型模式**，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。   
　　　　**行为型模式**，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

***1.单例者模式（懒汉式和饿汉式）***

所谓的单例设计指的是一个类只允许产生一个实例化对象。

**饿汉式**：构造方法私有化，先创建对象*　　　　　*

class Singleton \{  
　　　　　　　　　　/\*\*  
　　　　　　　　　　\* 在类的内部可以访问私有结构，所以可以在类的内部产生实例化对象  
　　　　　　　　　　\*/  
　　　　　　　　private static Singleton instance = new Singleton();  
　　　　　　　　　　/\*\*  
　　　　　　　　　　\* private 声明构造  
　　　　　　　　　　\*/  
　　　　　　　　private Singleton() \{

\}  
　　　　　　　　　　/\*\*  
　　　　　　　　　　\* 返回对象实例  
　　　　　　　　　　\*/  
　　　　　　　　public static Singleton getInstance() \{  
　　　　　　　　　　return instance;  
　　　　　　　　\}

*　　　　***懒汉式*：***构造方法私有，当第一使用的时候才*去创建对象，*存在线程安全问题，所以用到了 synchronized 来实现线程的同步，

class Singleton \{

/\*\*  
　　　　　　　　\* 声明变量  
　　　　　　　　\*/  
　　　　　　　　private static volatile Singleton singleton = null;

/\*\*  
　　　　　　　　\* 私有构造方法  
　　　　　　　　\*/  
　　　　　　　　private Singleton() \{

/\*\*  
　　　　　　　　\* 提供对外方法  
　　　　　　　　\*/  
　　　　　　　　public static Singleton getInstance() \{  
　　　　　　　　// 还未实例化  
　　　　　　　　　　if (singleton == null) \{  
　　　　　　　　　　　　synchronized (Singleton.class) \{  
　　　　　　　　　　　　　　if (singleton == null) \{  
　　　　　　　　　　　　　　　　singleton = new Singleton();  
　　　　　　　　　　　　　　　\}  
　　　　　　　　　　　　\}  
　　　　　　　　　　\}  
　　　　　　　　　　return singleton;  
　　　　　　　　\}  
　　　　　　\}

**　2.工厂设计模式（工厂方法模式和抽象工厂模式）**

**1.工厂方法模式　　**

（1）普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

interface Sender \{  
void Send();  
\}

class AppleSender implements Sender \{

@Override  
public void Send() \{  
System.out.println("This is apple sender...");  
\}  
\}

class BananaSender implements Sender \{

@Override  
public void Send() \{  
System.out.println("This is banana sender...");  
\}  
\}

public class FactoryPattern \{  
public static void main(String\[\] args) \{  
Sender sender = produce("apple");  
sender.Send();  
\}  
public static Sender produce(String str) \{  
if ("apple".equals(str)) \{  
return new AppleSender();  
\} else if ("banana".equals(str)) \{  
return new BananaSender();  
\} else \{  
System.out.println("没有该类对象.");  
return null;  
\}  
\}  
\}

（2） 多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。

interface Sender \{  
void Send();  
\}

class AppleSender implements Sender \{

@Override  
public void Send() \{  
System.out.println("This is apple sender...");  
\}  
\}

class BananaSender implements Sender \{

@Override  
public void Send() \{  
System.out.println("This is banana sender...");  
\}  
\}

class SendFactory \{  
public Sender produceApple() \{  
return new AppleSender();  
\}

public Sender produceBanana() \{  
return new BananaSender();  
\}  
\}

public class FactoryPattern \{  
public static void main(String\[\] args) \{  
SendFactory factory = new SendFactory();  
Sender sender = factory.produceApple();  
sender.Send();  
\}  
\}　　　　　　（3） 静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

就是在上边的类SendFactory中的produceApple()方法前加static，然后在public FactoryPattern中直接调用*produceApple()即可*

*　　　　***2.抽象工厂模式*****　　　　　***

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要扩展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，那么这就用到了抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

interface Provider \{  
Sender produce();  
\}

interface Sender \{  
void Send();  
\}

class AppleSender implements Sender \{

@Override  
public void Send() \{  
System.out.println("This is apple sender...");  
\}  
\}

class BananaSender implements Sender \{

@Override  
public void Send() \{  
System.out.println("This is banana sender...");  
\}  
\}

class SendAppleFactory implements Provider \{

public Sender produce() \{  
return new AppleSender();  
\}  
\}

class SendBananaFactory implements Provider \{

public Sender produce() \{  
return new BananaSender();  
\}  
\}

public class FactoryPattern \{  
public static void main(String\[\] args) \{  
Provider provider = new SendAppleFactory();  
Sender sender = provider.produce();  
sender.Send();  
\}  
\}

**3.建造者模式**

工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种类集中起来管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性。

public class TicketHelper\{

public void buildAdult(String info)\{

System.out.println("构建成年人票逻辑"+info);

public void buildChildren(String info)\{

System.out.println("构建儿童票逻辑"+info);

public void buildElderly(String info)\{

System.out.println("构建老年人票逻辑"+info);

public class TicketBuilder\{

public static Object builder(TicketHelper helper)\{

System.out.println("通过TicketHelper构建套票信息");

//测试

public static void mian(String \[\] args)\{

TicketHelper helper=new TicketHepler();

helper.buildAdult("成人票");

helper.buildChildren("儿童票");

helper.buildElderly("老年票");

Object ticket=TicketBuilder.builder(helper);

**4.装饰者模式**

顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。装饰者模式就是再创一个类来加强主类的功能，这样的话就不用为每个子类创建子类来加强那个子类； 具体方法就是在新创的类中，声明一个主类，就像声明成员变量那样（主类名 变量名），然后重写新类的构造方法， 构造方法中将参数类型设置为主类的类型，然后写要加强的方法。调用时就直接调用新类并创建对象，然后调用新类的方法 就能实现加强的目的。

interface Shape \{  
void draw();  
\}

/\*\*  
\* 实现接口的实体类  
\*/  
class Rectangle implements Shape \{

@Override  
public void draw() \{  
System.out.println("Shape: Rectangle...");  
\}  
\}

class Circle implements Shape \{

@Override  
public void draw() \{  
System.out.println("Shape: Circle...");  
\}  
\}

/\*\*  
\* 创建实现了 Shape 接口的抽象装饰类。  
\*/  
abstract class ShapeDecorator implements Shape \{  
protected Shape decoratedShape;

public ShapeDecorator(Shape decoratedShape) \{  
this.decoratedShape = decoratedShape;  
\}

@Override  
public void draw() \{  
decoratedShape.draw();  
\}  
\}

/\*\*  
\* 创建扩展自 ShapeDecorator 类的实体装饰类。  
\*/  
class RedShapeDecorator extends ShapeDecorator \{

public RedShapeDecorator(Shape decoratedShape) \{  
super(decoratedShape);  
\}

@Override  
public void draw() \{  
decoratedShape.draw();  
setRedBorder(decoratedShape);  
\}

private void setRedBorder(Shape decoratedShape) \{  
System.out.println("Border Color: Red");  
\}  
\}

**5.代理模式（静态代理和动态代理）**

代理模式指给一个对象提供一个代理对象，并由代理对象控制对原对象的引用。代理可以分为静态代理和动态代理。  
通过代理模式，可以利用代理对象为被代理对象添加额外的功能，以此来拓展被代理对象的功能。可以用于计算某个方法执行时间，在某个方法执行前后记录日志等操作。

**1. *静态代理***

*　　　　　　静态代理需要我们写出代理类和被代理类，而且一个代理类和一个被代理类一一对应。代理类和被代理类需要实现同一个接口，通过聚合使得代理对象中有被代理对象的引用，以此实现代理对象控制被代理对象的目的。*

/\*\*  
 \* 代理类和被代理类共同实现的接口  
 \*/  
interface IService \{

void service();  
\}

/\*\*  
 \* 被代理类  
 \*/  
class Service implements IService\{

@Override  
 public void service() \{   
 System.out.println("被代理对象执行相关操作");  
 \}  
\}

/\*\*  
 \* 代理类  
 \*/  
class ProxyService implements IService\{   
 /\*\*  
 \* 持有被代理对象的引用  
 \*/  
 private IService service;

/\*\*  
 \* 默认代理Service类  
 \*/  
 public ProxyService() \{   
 this.service = new Service();  
 \}

/\*\*  
 \* 也可以代理实现相同接口的其他类  
 \* @param service  
 \*/  
 public ProxyService(IService service) \{   
 this.service = service;  
 \}

@Override  
 public void service() \{   
 System.out.println("开始执行service()方法");  
 service.service();  
 System.out.println("service()方法执行完毕");  
 \}  
\}

//测试类  
public class ProxyPattern \{

public static void main(String\[\] args) \{   
 IService service = new Service();  
 //传入被代理类的对象  
 ProxyService proxyService = new ProxyService(service);  
 proxyService.service();  
 \}  
\}

**2. 动态代理（jdk动态代理和cglib动态代理）一下使用的jdk动态代理和cglb动态代理的区别就是 jdk动态代理需要一个接口**  
　　　　　　JDK 1.3 之后，Java通过java.lang.reflect包中的三个类Proxy、InvocationHandler、Method来支持动态代理。动态代理常用于有若干个被代理的对象，且为每个被代理对象添加的功能是相同的（例如在每个方法运行前后记录日志）。

动态代理的代理类不需要我们编写，由Java自动产生代理类源代码并进行编译最后生成代理对象。   
　　　　　　创建动态代理对象的步骤：   
　　　　　　　　1. 指明一系列的接口来创建一个代理对象   
　　　　　　　　2. 创建一个调用处理器（InvocationHandler）对象   
　　　　　　　　3. 将这个代理指定为某个其他对象的代理对象   
　　　　　　　　4. 在调用处理器的invoke（）方法中采取代理，一方面将调用传递给真实对象，另一方面执行各种需要的操作

import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;

/\*\*  
 \* 代理类和被代理类共同实现的接口  
 \*/  
interface IService \{   
 void service();  
\}

class Service implements IService\{

@Override  
 public void service() \{   
 System.out.println("被代理对象执行相关操作");  
 \}  
\}

class ServiceInvocationHandler implements InvocationHandler \{

/\*\*  
 \* 被代理的对象

\*代理对象和被代理对象之间的依赖关系  
 \*/  
 private Object srcObject;

public ServiceInvocationHandler(Object srcObject) \{   
 this.srcObject = srcObject;  
 \}

/\*\*

\*代理逻辑

\*/

@Override  
 public Object invoke(Object proxyObj, Method method, Object\[\] args) throws Throwable \{   
 System.out.println("开始执行"+method.getName()+"方法");  
 //执行原对象的相关操作，容易忘记  
 Object returnObj = method.invoke(srcObject,args);  
 System.out.println(method.getName()+"方法执行完毕");  
 return returnObj;  
 \}  
\}

public class ProxyPattern \{   
 public static void main(String\[\] args) \{   
 IService service = new Service();  
 Class<? extends IService> clazz = service.getClass();

IService proxyService = (IService) Proxy.newProxyInstance(clazz.getClassLoader(),  
 clazz.getInterfaces(), new ServiceInvocationHandler(service));  
 proxyService.service();  
 \}  
\}

***三、mybatis执行流程和底层原理***

**　　mybatis执行流程**

**　　　　**1.在lib下导入java包

2.编写数据库中的表对应的pojo

3.编写mybatis和核心配置文件（加载mapper映射文件）

4.编写接口和对应的mapper映射文件（映射文件中的nameSpace是对应的接口的权限定名，查询语句中的id是接口中的方法名，parameterType是接口中方法的参数类型，resultType是接口中的方法的返回值，也可以是resultMap编写的pojo中的成员变量和数据库表字段的对应关系）

5.然后通过核心配置文件中的mapper和mapper映射文件实现映射器，主要pojo属性和表字段对应，就可以自动映射。

1.在查询语句中可以使用注解传递多个参数 @param 如果数据过多的话 使用pojo

2.\#和$ 如果表名是变化的则必须使用$,order by 后必须使用$

3.一对一的级联 在mapper映射文件中 通过association 元素代表一对一级联的开始，property代表映射到的pojo属性，column代表sql列，select配置对应的命名空间，这样便可以指出对应mapper的sql，mybatis就会通过对应的sql将数据查询回来

一对多的级联 在mapper映射文件中 通过collection配置，并且在pojo中 一的一方配置多的一方的组合用集合的方式，property代表一的一方中组合的属性名，

4.延迟加载 lazyLoadingEnabled默认是false，和 aggressiveLazyLoading 默认false

5.动态sql，choose，when，otherwise， trim， where，set，foreach

**底层原理**

通过动态代理实现mapper自动映射

**四、Spring （spring IOC 和 Spring AOP）**

spring依赖注入的三种方式：1.构造器注入 2.setter注入 3.接口注入

spring装配bean的三种方式：1.在xml中显示配置 2.在java接口和类中实现配置 3.隐式Bean的发现机制和自动装配原则

使用xml装配bean，只需要在配置文件中编写 bean标签，里边配置property 的name 和 value

通过注解装配bean，@Component，代表 spring ioc会把这个类扫描成bean实例，这样spring ioc 并不知道去哪里扫描，所以就有@ComponentScan 代表全表扫描，默认是当前包的路径。 -----这个一般不使用

@Autowired（required="false|true"）默认是true就是必须注入成功， 自动装配，如果一个接口下不只有一个实现类的话，使用在动装配存在歧义，所以使用@Primary和@Qualifier，注解@Primary写在具体的实现类上，代表这个类优先注入，但是这并不能解决实际问题，可以 使用@Qualifier（“在具体的实现类中起的别名”）写在@Autowired的下边

Spring IOC 底层采用是反射，IOC的设计是基于BeanFactory

转载于:https://www.cnblogs.com/xp0813/p/11310932.html