Java设计模式模块9面试试题以及答案

@Ta 06-10 21:25 61点击
Java设计模式模块9面试试题以及答案
整理抄写:王耀国春飞wygcf

说一下你熟悉的设计模式?

单例模式
简单点说,就是一个应用程序中,某个类的实例对象只有一个,你没有办法去new,因为构造器是被private修饰的,一般通过getInstance()的方法来获取它们的实例。
getInstance()的返回值是一个对象的引用,并不是一个新的实例,所以不要错误的理解成多个对象。单例模式实现起来也很容易,直接看demo吧。

// @by 王耀国春飞wygcf

public class Singleton {
    private static Singleton singleton;
    private static () {}
        public static Singleton getInstance() {
            if (singleton == null) {
                singleton = new Singleton();
                }
                return singleton;              
            }        
}

按照我的习惯,我恨不得写满注释,怕你们看不懂,但是这个代码实在太简单了,所以我没写任何注释,如果这几行代码你都看不明白的话,那你可以洗洗睡了。
等你睡醒了再来看我的博客说不定能看懂。

上面的是最基本的写法,也叫懒汉写法(线程不安全),下面我再公布几种单例模式的写法:

懒汉式写法(线程安全)

// @by 王耀国春飞wygcf

public class Singleton {
    private static Singleton instance;
    private Singleton () {} 
    public static synchronized Singleton getInstance() {
    if (instance == null) {
        instance = new Singleton();
    }
    return instance;
    }
}

饿汉式写法

// @by 王耀国春飞wygcf

public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton () {}
    public static Singleton getInstance() {
    return instance;
    }
}

静态内部类

// @by 王耀国春飞wygcf

public class Singleton {
    private static class SingletonHolder {
    private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton () {}
    public static final Singleton getInstance() {
    return SingletonHolder.INSTANCE;
    }
}

枚举

// @by 王耀国春飞wygcf

public enum Singleton {
    INSTANCE;
    public void whateverMethod() {
    }
}

这种方式是Effective Java作者Josh Bloch 提倡的方式,它不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象,可谓是很坚强的壁垒啊。
不过,个人认为由于1.5中才加入enum特性,用这种方式写不免让人感觉生疏。

双重校验锁

// @by 王耀国春飞wygcf

public class Singleton {
   private volatile static Singleton singleton;
   private Singleton () {}
   public static Singleton getSingleton() {
   if (singleton == null) {
       synchronized (Singleton.class) {
           singleton = new Singleton();
       }
   }
   return singleton;
   }
}

总结:我个人比较喜欢静态内部类写法和饿汉式写法,其实这两种写法能够应付绝大多数情况了。
其实写法也可以选择,主要还是看业务需求了。

观察者模式
对象间一对多的依赖关系,当一个对象的状态发送改变时,所有依赖于它的对象都得到通知并被自动更新。

ConcreteSubject —> Subject[+ Attach(o: Observer)][+ detach(o: Observer)][+ Notify()] —> (+subject) Observer[+ update()] <— ConcreteObserver

观察者模式图

看不懂图的人端着小板凳到这里来,给你举个例子:假设有三个人,小美(女,22岁),小王和小李。
小美很漂亮,小王和小李是两个程序员,时刻关注着小美的一举一动。
有一天,小美说了一句:"谁来陪我打游戏?"
这句话被小王和小李听到,结果乐坏了。蹭蹭蹭,没一会儿小王就来到了小美家门口。
在这里,小美是被观察者,小王和小李是观察者,被观察者发出一条信息,然后观察者们进行相应的处理。
看代码:

// @by 王耀国春飞wygcf

public interface Person {
    //小王和小李通过这个接口可以接收到小美发过来的消息
    void getMessage(String s);
}

这个接口相当于小王和小李的电话号码,小美发送通知的时候就会拨打getMessage这个电话,拨打电话就是调用接口,看不懂没关系,先往下看:

// @by 王耀国春飞wygcf

public class XiaoWang implements Person {
    private String name = "小王";
    public XiaoWang() {}

   @Overide
   public void getMessage(String s) {
       System.out.println(name + "接到小美打过来的电话,电话内容是:" + s);       
   }
}
public class XiaoLi implements Person {
    private String name = "小李";
    public XiaoLi() {}
    
    @Overide
    public void getMessage(String s) {
        System.out.println(name + "接到小美打过来的电话,电话内容是:" + s);
    }
}

代码很简单,我们再看看小美的代码:

public class XiaoMei {
    List<Person> list = new ArrayList<Person>();
    public XiaoMei() {}
    public void addPerson(Person person){
        list.add(person);
    }
    // 遍历list,把自己的通知发送给所有暗恋自己的人
    public void notifyPerson() {
        for(Person person:list) {
            person.getMessage("你们过来吧,谁先过来谁就能陪我一起玩儿游戏!");
        }
    }
}

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

// @by 王耀国春飞wygcf

public class Test {
    public static void main(String[] args) {
        XiaoMei xiao_mei = new XiaoMei();
        XiaoWang xiao_wang = new XiaoWang();
        XiaoLi xiao_li = new XiaoLi();        
        //小王和小李在小美那里都注册了一下
        xiao_mei.addPerson(xiao_wang);
        xiao_mei.addPerson(xiao_li);
        //小美向小王和小李发送通知
        xiao_mei.notifyPerson();    
    }
}

完美结束

装饰者模式

对已有的业务逻辑进一步的封装,使其增加额外的功能,如Java中的IO流就使用了装饰者模式,用户在使用的时候,可以任意组装,达到自己想要的结果。
举个例子,我想吃三明治,首先我需要一根大大的香肠,我喜欢吃奶油,在香肠上面加一点奶油,再放一点蔬菜,最后再用两片面包夹一下,很丰盛的一顿午饭,营养又健康。
那我们应该怎么来写代码呢?首先,我们需要写一个Food类,让其他所有食物都来继承这个类,看代码:

// @by 王耀国春飞wygcf

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;
    };
}

代码很简单,我就不解释了,然后我们写几个子类继承它:

//面包类
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()+"+蔬菜";
    }
}

这几个类都是差不多的,构造方法传入一个Food类型的参数,然后在make方法中加入一些自己的逻辑,如果你还是看不懂为什么这么写,不急,你看看我的Test类是怎么写的,一看你就明白了

// @by 王耀国春飞wygcf

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的电压和手机联系起来了。

// @by 王耀国春飞wygcf

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.chargeVoltage();
    }
    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");        
    }
}

输出结果:
正在充电…
原始电压:220
经过变压器转换之后的电压:20

工厂模式

简单工厂模式:
一个抽象的接口,多个抽象接口的实现类,一个工厂类,用来实例化抽象的接口。

// @by 王耀国春飞wygcf

// 抽象产品类
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("造不了这种汽车……");
        }
    }
}

工厂方法模式:有四个角色,抽象工厂模式,具体工厂模式,抽象产品模式,具体产品模式。
不再是由一个工厂类去实例化具体的产品,而是由抽象工厂的子类去实例化产品。

// @by 王耀国春飞wygcf

// 抽象产品角色
public interface Moveable {
    void run();
}
// 具体产品角色
public class Plane implements Moveable {
    @Override
    public void run() {
        System.out.println("plane……");
    }
}
public class Broom implements Moveable {
    @Override
    public void run() {
        System.out.println("broom……");
    }
}
// 抽象工厂
public abstract class VehicleFactory {
    abstract Moveable create();
}
// 具体工厂
public class PlaneFactory extends VehicleFactory {
    public Moveable create() {
        return new Plane();
    }
}
public classBroomFactory extends VehicleFactory {
    public Moveable create() {
        return new Broom();
    }
}
// 测试类
public class Test {
    public static void main(String[] args) {
       VehicleFactory factory = new BroomFactory();
       Moveable m = factory.create();
       m.run();
    }
}

抽象工厂模式:与工厂方法模式不同的是,工厂方法模式中的工厂只生产单一的产品,而抽象工厂模式中的工厂生产多个产品

// @by 王耀国春飞wygcf

// 抽象工厂类
public abstract class AbstractFactory {
    public abstract Vehicle createVehicle();
    public abstract Weapon createWeapon();
    public abstract Food createFood();
}
// 具体工厂类
public class DefaultFactory extends AbstractFactory{
    @Override
    public Food createFood() {
        return new Apple();
    }
    @Override
    public Food createVehicle() {
        return new Car();
    }
    @Override
    public Weapon createWeapon() {
        return new AK47();
    }
}
// 测试类
public class Test {
    public static void main(String[] args) {
        AbstractFactory f = new DefaultFactory();
        Vehicle v = f.createVehicle();
        v.run();
        Weapon w = f.createWeapon();
        w.shoot();
        Food a = f.createFood();
        a.printName();
    }
}

代理模式(proxy)
有两种,静态代理和动态代理。

// @by 王耀国春飞wygcf

代码实现请看:
// 代理接口
public interface ProxyInterface {
    void marry();
    // 代理结婚
}

婚庆公司代码:
public class WeddingCompany implements ProxyInterface {
    public ProxyInterface proxyInterface;
    private WeddingCompany(ProxyInterface proxyInterface) {
        this.proxyInterface = proxyInterface;
    }
    @Override
    public void marry() {
    System.out.println("婚庆公司为我们结婚的工作做了准备。");
    proxyInterface.marry();
    System.out.println("结婚完毕");
    }
}
public class NormalHome implements ProxyInterface {
    @Override
    public void marry() {
    System.out.println("我们结婚啦!");
    }
}

测试代码:
public class Test {
    public static void main(String[] args) {
    ProxyInterface proxyInterface = new WeddingCompany(new NormalHome());
    proxyInterface.marry();
    }
}

简单工厂和抽象工厂有什么区别?
简单工厂模式:
这个模式本身很简单而且使用在业务较简单的情况下。一般用于小项目或者具体产品很少拓展的情况(这样工厂类才不会经常更改)。
它有三种角色组成:
工厂类角色:这是本模式的核心,含有一定的商业逻辑和判断逻辑,根据逻辑不同,产生具体的工厂产品。如例子中的Driver类。
抽象产品角色:它一般是具体产品继承的父类或者实现的接口。由接口或者抽象类来实现。如例子中的Car接口。
具体产品角色:工厂类所创建的对象就是此角色的实例。在Java中由一个具体类实现,如例子中的Benz、Bmw类。

来用类图来清晰的表示下它们之间的关系:
简单工厂模式:

                        /——SimpleFactory               
                       /           
  FactoryClient ———         ↓   
                       \           
                        \——AbstractProduct 
                              ↗      ↖
                              /        \
                             /          \
    ConcreteProduct2 ————           ————ConcreteProduct1
    
抽象工厂模式:
先来认识一下什么是产品族:位于不同产品等级结构中,功能相关联的产品组成的家庭。    

        
                                   Client—————————————————————————————AbstractFactory
                                      |                                                          /       \
                                      |                                                         /         \
                                      |                                                        /           \                                 
                                      |                                                       /             \
                                      |                                                      /               \
                                      |                                                     /                 \
                              AbstractProductA                              ConcreteFactory1          ConcreteFactory2
                                  /   |    \                                         |                               |
                                 /    |     \                                        |                               |
                                /     |      \                                       |                               |
                               /      |       \                                      |                               |
                              /       |        \                                     |                               |
            ConcreteProductA1             ConcreteProductA2                     
        (Class Logical View::AbstractFactory::ConcreteProductA1)                 
                                      
                                      |                                              |                               |
                                      |                                              |                               |
                              AbstractProductB
                                  /        \                                         |                               |
                                 /          \
                                /            \                                       |                               |
                               /              \
             ConcreteProductB1           ConcreteProductB2     
                     |                                  |                            |                                |
                     |                                  |                            |                                |
                     |                                  |                            |                                |
                     |                                  ——————————————————————————————————
                     |                                                               |
                     ————————————————————————————————————
            
 productA 和 productB 分别是一个产品树
 productA1 和 ProductB1 属于是一个产品族
 productA2 和 productB2 属于是一个产品族
 
使用抽象工厂模式还要满足一下条件:
1. 系统中有多个产品族,而系统一次只可能消费其中一族产品
2. 同属于同一个产品族的产品以其使用 

来看看抽象工厂模式的各个角色(和工厂方法的如出一辙):   
抽象工厂角色:这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。 
具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在Java中它由具体的类来实现。
抽象产品角色:它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
具体产品角色:具体工厂角色所创建的对象就是此角色的实例。在Java中由具体的类来实现。

为什么要使用 Spring ?    
简介
目的:解决企业应用开发的复杂性
功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能
范围:任何Java应用
简单来说,Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

轻量 
从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。
并且Spring所需的处理开销也是微不足道的。此外,Spring是非侵入式的:典型地,Spring应用中的对象不依赖于Spring的特定类。

控制反转
Spring通过一种称作控制反转(IoC)的技术促进了松耦合。当应用了IoC,一个对象依赖的其他对象会通过被动的方式传递进来,而不是这个对象自己创建或者查找依赖对象。
你可以认为IoC与JNDI相反 —— 不是对象从容器中查找依赖,而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

面向切面
Spring提供了面向切面编程的丰富支持,允许通过分离应用的业务逻辑与系统级服务(例如审计(auditing)和事物(transaction)管理)进行内聚性的开发。应用对象只实现它们应该做的 —— 完成业务逻辑 —— 仅此而已。
它们并不负责(甚至是意识)其它的系统级关注点,例如日志或事物支持。

容器
Spring包含并管理应用对象的配置和生命周期,在这个意义上它是一种容器,你可以配置你的每个bean如何被创建 —— 基于一个可配置原型(prototype),你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例 —— 以及它们是如何相互关联的。然而,Spring不应该被混同于传统的重量级的EJB容器,它们经常是庞大与笨重的,难以使用。

框架
Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中,应用对象被声明式地组合,典型地是在一个XML文件里。Spring也提供了很多基础功能(事物管理、持久化框架集成等等),将应用逻辑的开发留给了你。
所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

解释一下什么是 aop ?
AOP(Aspect-Oriented Programming,面向方面编程),可以说是OOP(Object-Oriented Programming,面向对象编程)的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构,用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候,OPP则显得无能为力。也就是说,OOP允许你定义从上到下的联系,但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散步在所有对象层次中,而与它所散布到的对象的核心功能毫无关系。
对于其他类型的代码,如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切(cross-cutting)代码,在OOP设计中,它导致了大量代码的重复,而不利于各个模块的重用。

而AOP技术则恰恰相反,它利用一种称为"横切"的技术,剖解开封装的对象内部,并将那些影响了多个类的公共行为封装到一个可重用模块,并将其名为"Aspect",即方面。
所谓"方面",简单地说,就是将那些与业务无关,却为业务模块所共同调用的逻辑或责任封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可操作性和可维护性。
AOP代表的是一个横向的关系,如果说"对象"是一个空心的圆柱体,其中封装的是对象的属性和行为;那么面向方面编程的方法,就仿佛一把利刃,将这些空心圆柱体剖开,以获得其内部的消息。而剖开的切面,也就是所谓的"方面"了。然后它有以巧夺天工的妙手将这些剖开的切面复原,不留痕迹。

使用“横切”技术,AOP把软件系统分为两个部分:核心关注点和横切关注点。业务处理的主要流程是核心关注点,与之关系不大的部分是横切关注点。横切关注点的一个特点是,他们经常发生在核心关注点的多处,而各处都基本相似。比如权限认证、日志、事务处理。Aop 的作用在于分离系统中的各种关注点,将核心关注点和横切关注点分离开来。
正如Avanade公司的高级方案构架师Adam Magee所说,AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离。”

使用"横切"技术,AOP把软件系统分为两个部分:核心关注点和横切关注点。业务处理的主要流程是核心关注点,与之关系不大的部分是横切关注点。横切关注点的一个特点是,他们经常发生在核心关注点的多处,而各处都基本相似。比如权限认证、日志、事物处理。AOP的作用在于分离系统中的各种关注点,将核心关注点和横切关注点分离开来。
正如Avanade公司的高级方案架构师Adam Magee所说,AOP的核心思想就是"将应用程序中的商业逻辑同对其提供支持的通用服务就行分离。"

解释一下什么是 ioc ?
IOC是Inversion of Control的缩写,多数书籍翻译成"控制反转"。
1996年,Michael Mattson在一篇有关探讨面向对象框架的文章中,首先提出了IOC这个概念。对于面向对象设计及编程的基本思想,前面我们已经讲了很多了,不再赘述,简单来说就是把复杂系统分解成相互合作的对象,这些对象类通过封装以后,内部实现对外部是透明的,从而降低了解决问题的复杂度,而且可以灵活地被重用和拓展。

IOC理论提出的观点大体是这样的:借助于"第三方"实现具有依赖关系的对象之间的解耦。如下图:



             Object A ————齿轮—————   —————齿轮———— Object B         
                                            | |
                                         IOC容器(齿轮)
                                            | |
             Object C ————齿轮—————   —————齿轮———— Object D     
                                       (我是第三方)  手上
                                                                               
图 IOC解耦过程
大家看到了吧,由于引进了中间位置的"第三方",也就是IOC容器,使得A、B、C、D这四个对象没有了耦合关系,齿轮之间的传动全部依靠"第三方"了,全部对象的控制权全部上缴给"第三方"IOC容器。
所以,IOC容器成了整个系统的关键核心,它起到了一种类似"粘合剂"的作用,把系统中的所有对象粘合在一起发挥作用,如果没有这个"粘合剂",对象与对象之间会彼此失去联系,这就是有人把IOC容器比喻成"粘合剂"的由来。

我们再来做个试验:把上图中间的IOC容器拿掉,然后再来看看这套系统:

                     Object A ————齿轮    齿轮———— Object B                                                                                              

                                            
                     Object C ————齿轮    齿轮———— Object D     
                     
                                  (拿掉IOC容器后的系统)

我们现在看到的画面,就是我们要实现整个系统所需要完成的全部内容。这时候,A、B、C、D这四个对象之间已经没有耦合关系了,彼此毫无联系,
这样的话,当你在实现A的时候,根本无需再去考虑B、C和D了,对象之间的依赖关系已经降低到了最低程度。 
所以,如果真能实现IOC容器,对于系统开发而言,这将是一件多么美好的事情,参与开发的每一成员只要实现自己的类就可以了,跟别人没有任何关系!   

我们再来看看,控制反转(IOC)到底为什么要起这么个名字?我们来对比一下:
软件系统在没有引入IOC容器之前,如图所示,对象A依赖于对象B,那么对象A在初始化或者运行到某一点的时候,自己必须主动去创建对象B或者使用已经创建的对象B。无论是创建还是使用对象B,控制权都在自己手上。
软件系统在引入IOC容器之后,这种情形就完全改变了,如图所示,由于IOC容器的加入,对象A与对象B之间失去了直接联系。所以,当对象A运行到需要对象B的时候,IOC容器会主动创建一个对象B注入到对象A需要的地方。
通过前后对比,我们不难看出来:对象A获得依赖对象B的过程,由主动行为变成了被动行为,控制权颠倒过来了,这就是"控制反转"这个名称的由来。

Spring 有哪些主要模块?
Spring框架至今已集成了20多个模块。这些模块主要被分为 核心容器、数据访问/集成、Web、AOP(面向切面编程) 、工具、消息和测试模块。

更多信息:howtodoinjava.com/java-spring-framework-tutorials/   

Spring 常用的注入方式有哪些?
Spring通过DI(依赖注入) 实现IOC(控制反转),常用的注入方式主要有三种:
1. 构造方法注入
2. setter注入
3. 基于注解的注入   

Spring 支持几种 bean 的作用域?
当通过Spring容器创建一个Bean实例时,不仅可以完成Bean实例的实例化,还可以为Bean指定特定的作用域。Spring支持如下5种作用域:

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时,该作用域才有效

其中比较常用的是singleton和prototype两种作用域。对于singleton作用域的Bean,每次请求该Bean都将获得相同的实例。容器负责跟踪Bean实例的状态,负责维护Bean实例的生命周期行为;如果一个Bean被设置成prototype作用域,程序每次请求该id的Bean,Spring都会新建一个Bean实例,然后返回给程序。在这种情况下,Spring容器仅仅使用new关键字创建Bean实例,一旦创建成功,容器不在跟踪实例,也不会维护Bean实例的状态。
如果不指定Bean的作用域,Spring默认使用singleton作用域。Java在创建Java实例时,需要进行内存申请;销毁实例时,需要完成垃圾回收,这些工作都会导致系统开销的增加。因此,prototype作用域Bean的创建、销毁代价比较大。而singleton作用域的Bean实例一旦创建成功,可以重复使用。因此,除非必要,否则尽量避免将Bean设置成prototype作用域。

Spring 自动装配 Bean 有哪些方式?
Spring容器负责创建应用程序中的bean同时通过ID来协调这些对象之间的关系。作为开发人员,我们需要告诉Spring要创建哪些bean并且如何将其装配到一起。
spring中bean装配有两种方式:
隐式的bean发现机制和自动装配
在Java代码或者xml中进行显示配置
当然这些方式也可以配合使用   

spring 事务实现方式有哪些?
编程式事务管理对基于 POJO 的应用来说是唯一选择。我们需要在代码中调用beginTransaction()、commit()、rollback()等事务管理相关的方法,这就是编程式事务管理。
基于 TransactionProxyFactoryBean 的声明式事务管理
基于 @Transactional 的声明式事务管理
基于 Aspectj AOP 配置事务

说一下 Spring 的事务隔离?
事务隔离级别指的是一个事务对数据的修改与另一个并行的事务的隔离程度,当多个事务同时访问相同数据时,如果没有采取必要的隔离机制,就可能发生以下问题:
脏读:一个事务读到另一个事务未提交的更新数据
幻读:例如第一个事务对一个表中的数据进行了修改,比如这种修改涉及到表中的"全部数据行"。同时,第二个事务也修改这个表中的数据,这种修改是向表中插入"一行新数据"。那么,以后就会发生操作第一个事务的用户发现表中还存在没有修改的数据行,就好像发生了幻觉一样。
不可重复读:比方说在同一个事务中先后执行两条一模一样的select语句,期间在此次事务中没有执行过任何DDL语句,但先后得到的结果不一致,这就是不可重复读。

Spring运行流程描述:
1. 用户向服务器发送请求,请求被Spring前端控制Servlet DispatcherServlet捕获;
2. DispatcherServlet对请求URL进行解析,得到请求资源标识符(URL)。然后根据该URL,调用HandlerMapping获得该Handler配置的所有相关的对象(包括Handler对象以及Handler对象对应的拦截器),最后以HandlerExecutionChain对象的形式返回;
3. DispatcherServlet根据获得的Handler,选择一个合适的HandlerAdapter;(附注:如果成功获得HandlerAdapter后,此时将开始执行拦截器的preHandler(…)方法)
4. 提取Request中的模型数据,填充Handler入参,开始执行Hnadler(Controller)。在填充Handler的入参过程中,根据你的配置,Spring将帮助你做一些额外的工作:

●HttpMessageConveter:将请求消息(如Json、xml等数据)转换成一个对象,将对象转换为指定的响应信息
●数据转换:对请求的消息进行数据转换。如String转换成Integer、Double等
●数据格式化:对请求消息进行数据格式化
●数据验证:验证数据的有效性(长度、格式等),验证结果存储到BindingResult或Error中

5. Handler执行完成后,向 DispatcherServlet 返回一个ModelAndView对象;
6. 根据返回的ModelAndView,选择一个适合的ViewResolver(必须是自己已经注册到Spring容器中的ViewResolver)返回给DispatcherServlet;
7. ViewResolver结合Model和View,来渲染视图;
8. 将渲染结果返回给客户端。

Spring Mvc 有哪些组件?
Spring MVC的核心组件:
DispatcherServlet:中央控制器,把请求给转发到具体的控制类
Controller:具体处理请求的控制器
HandlerMapping:映射处理器,负责映射中央处理器转发给Controller时的映射策略
ModelAndView:服务层返回的数据和视图层的封装类
ViewResolver:视图解析器,解析具体的视图
Interceptors:拦截器,负责拦截我们定义的请求然后做处理工作

@RequestMapping的作用是什么
RequestMapping 是一个用来处理请求地址映射的注解,可用于类或方法上。用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径。
RequestMapping 注解有六个属性,下面我们把它分成三类进行说明。

Value、Method:
Value:指定请求的实际地址,指定的地址可以是URL Template 模式(后面将会说明);
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值,才能让该方法处理请求。

@Autowired用法讲解

首先要知道另一个东西,default-autowire,它是在xml文件中进行配置的,可以设置为byName、byType、constructor和autodetect;比如byName,不用显示的在bean中写出依赖的对象,它会自动的匹配其它bean中id名与bean的setMaster(…)相同的,并自动装载。
@Autowired是用在JavaBean中的注解,通过byType形式,用来给指定的字段或方法注入所需的外部资源。
两者的功能是一样的,就是能减少或者消除属性或构造器参数的设置,只是配置地方不一样而已。

autowire四种模式的区别:
byName:根据属性名自动装配。此选项将检查容器并根据名字查找与属性完全一致的bean,并将其与属性自动装配。例如,在bean定义中将autowire设置为 by name ,而该 bean 包含Master属性(同时提供SetMaster(…)方法),Spring就会查找名为master的bean定义,并用它来装配给master属性。
byType:如果容器中存在一个与指定属性类型相同的bean,那么将与该属性自动装配。如果存在多个该类型的bean,那么将会抛出异常,并指出不能使用byType方式进行自动装配。若没有找到相匹配的bean,则什么事都不会发生,属性也不会被设置。如果你不希望这样,那么可以通过设置 dependency-check = "object" 让Spring抛出异常。
constructor:与byType的方式类似,不同之处它应用于构造器参数。如果容器中没有找到与构造器参数类型一致的bean,那么将会抛出异常。
autodetect:通过bean类的自省机制(introspection)来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器,那么将使用byType方式。

先看一下bean实例化和@Autowired装配过程:
1. 一切都是从bean工厂的getBean方法开始的,一旦该方法调用总会返回一个bean实例,无论当前是否存在,不存在就实例化一个并装配,否则直接返回。(Spring MVC是在什么时候开始执行bean的实例化过程的呢?其实就在组件扫描完成之后)
2. 实例化和装配过程中会多次递归调用getBean方法来解决类之间的依赖。
3. Spring 几乎考虑了所有可能性,所以方法特别复杂但完整有条理。
4. @Autowired最终是根据类型来查找和装配元素的,但是我们设置了<beans default-autowire="byName"/>后会影响最终的类型匹配查找。因为在前面有根据BeanDefinition的autowire类型设置PropertyValue值得一步,其中会有新实例的创建和注册。就是那个autowireByName方法。

下面通过@Autowired来说明一下用法
Setter方法中的 @Autowired
你可以在 JavaBean中的 setter 方法中使用 @Autowired 注解。当 Spring 遇到一个在Setter方法中使用的@Autowired 注解,它会在方法中执行 byType 自动装配。
这里是 TextEditor.java 文件的内容:

package com.tutorialspoint;
import org.springframework.beans.factory.annotation.Autowired;
public class TextEditor {
    private SpellChecker spellChecker;
    @Autowired
    public void setSpellChecker( SpellChecker spellChecker ) {
        this.spellChecker = spellChecker;
    }
    public SpellChecker getSpellChecker() {
        return spellChecker;
    }
    public void spellCheck() {
        spellChecker.checkSpelling();
    }
}

下面是另一个依赖的类文件 SpellChecker.java 的内容:

package com.tutorialspoint;
public class SpellChecker {
    public SpellChecker() {
        System.out.println("Inside SpellChecker constructor.");
    }
    public void checkSpelling() {
        System.out.println("Inside checkSpelling.");
    }
}

下面是配置文件 Beans.xml:

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemalLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    
    <context:annotation-config/>
    <!-- Definition for textEditor bean without constructor-arg  -->
    <bean id="textEditor" class="com.tutorialspoint.TextEditor">
    </bean>

    <!-- Definition for spellChecker bean -->
    <bean id="spellChecker" class="com.tutorialspoint.SpellChecker">
    </bean>
    
</beans>

一旦你已经成功的创建了源文件和 bean 配置文件,让我们运行一下应用程序。如果你的应用程序一切都正常的话,这将会输出以下信息:

Inside SpellChecker constructor.
Inside checkSpelling.

属性中的 @Autowired
你可以在属性中使用 @Autowired 注解来除去 setter 方法。当时使用 为自动连续属性传递的时候,Spring 会将这些传递过来的值或者引用自动分配给那些属性。所以利用在属性中 @Autowired 的用法,你的 TextEditor.java 文件将变成如下所示:

package com.tutorialspoint;
import org.springframework.beans.factory.annotation.Autowired;
public class TextEditor {
    @Autowired
    private SpellChecker spellChecker;
    public TextEditor() {
        System.out.println("Inside TextEditor constructor.");
    }
    public SpellChecker getSpellChecker() {
        return spellChecker;
    }
    public void spellCheck() {
        spellChecker.checkSpelling();
    }
}

下面是配置文件 Beans.xml:

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

   <!-- Definition for textEditor bean -->
   <bean id="textEditor" class="com.tutorialspoint.TextEditor">
   </bean>

   <!-- Definition for spellChecker bean -->
   <bean id="spellChecker" class="com.tutorialspoint.SpellChecker">
   </bean>
   
</beans>

一旦你在源文件和 bean 配置文件中完成了上面两处改变,让我们运行一下应用程序。如果你的应用程序一切都正常的话,这将会输出以下消息:

Inside TextEditor constructor.
Inside SpellChecker constructor.
Inside checkSpelling.

构造函数中的 @Autowired
你也可以在构造函数中使用 @Autowired。一个构造函数 @Autowired 说明当创建 bean 时,即使在 XML 文件中没有使用 元素配置 bean ,构造函数也会被自动连接。让我们检查一下下面的示例。 

这里是 TextEditor.java 文件的内容:

package com.tutorialspoint;
import org.springframework.beans.factory.annotation.Autowired;
public class TextEditor {
    private SpellChecker spelChecker;
    @Autowired
    public TextEditor(SpellChecker spellChecker){
        System.out.println("Inside TextEditor constructor.");
        this.spellChecker = spellChecker;
    }
    public void spellCheck() {
        spellChecker.checkSpelling();
    }
}

下面是配置文件 Beans.xml:

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

   <!-- Definition for textEditor bean without constructor-arg  -->
   <bean id="textEditor" class="com.tutorialspoint.TextEditor">
   </bean>

   <!-- Definition for spellChecker bean -->
   <bean id="spellChecker" class="com.tutorialspoint.SpellChecker">
   </bean>

</beans>

一旦你在源文件和 bean 配置文件中完成了上面两处改变,让我们运行一下应用程序。如果你的应用程序一切都正常的话,这将会输出以下消息:

Inside TextEditor constructor.
Inside SpellChecker constructor.
Inside checkSpelling.

@Autowired 的(required=false)选项
默认情况下,@Autowired 注解意味着依赖是必须的,它类似于 @Required 注解,然而,你可以使用 @Autowired 的 (required=false) 选项关闭默认行为。
即使你不为 age 属性传递任何参数,下面的示例也会成功运行,但是对于 name 属性则需要一个参数。你可以自己尝试一下这个示例,因为除了只有 Student.java 文件被修改以外,它和 @Required 注解示例是相似的。

package com.tutorialspoint;
import org.springframework.beans.factory.annotation.Autowired;
public class Student {
    private Integer age;
    private String name;
    @Autowired(required=false)
    public void setAge(Integer age) {
        this.age = age;
    }
    public Integer getAge() {
        return age;
    }
    @Autowired
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}
回复列表(0)
帖子没有回复
添加新回复
回复需要登录

[聊天-公共聊天室] 寻梦xunm:@o, 广告位一个草根小破站http://huue.cc乎学技术自制小尾巴