Spring_シミュレーションはXML方式のSpringIOC(アナログ属性注入、構造方法注入、自動注入)に基づいています.

13941 ワード
Spring 4 xソース解析
1.制御反転概念:
制御反転は、比較的抽象的な概念であり、例を挙げて説明する.実際の生活の中で、人々は同じものを使う時、人々の基本的な考えはものを探し当てるので、例えばオレンジジュースを飲みたいです.これはあなた自身の「自発的」な創造の過程です.つまりオレンジジュースは自発的に創造する必要があります.ところが、今日になって、飲み物屋さんの人気があって、自分でジュースを搾る必要がなくなりました.オレンジジュースを飲みたいという考えが出たら、まず飲み物屋さんの連絡先を見つけて、電話やWeChatなどであなたの需要、住所、連絡先などを説明して、注文して待ってください.後でオレンジジュースを送る人がいます.あなたがオレンジジュースを作ったのではなく、オレンジジュースは飲み物屋さんによって作られたのです.あなたではなく、完全にあなたの要求に達しました.
制御反転は、説明(JavaではXMLまたは注釈)によって第三者によって特定のオブジェクトを生成または取得する方法である.
Springで制御反転を実現するのはIoC容器であり、その実現方法は注入に依存する.上述の例のように、ジュースメーカーは飲み物屋さんと注文書によってジュースを作っています.飲み物屋さんは他の人が作ったものです.ジュースを生産できるということを知っているだけでいいです.ジュースを作る方法を理解する必要はありません.
Spring IoC容器の設計は主にBeanFactoryとAppleication Controxtの二つのインターフェースに基づいています.その中でAppplication ContactはBenFactoryのサブインターフェースの一つです.つまりBenFactoryはSpring IoC容器で定義されている最下層インターフェースです.Application Contextはその高級な接続口の一つです.そのため、ほとんどの作業シーンでは、Application ContectをSpring IoC容器として使用しています.
2.アナログ制御反転
考え方:
  • オブジェクト情報は、XMLファイルに記述されている制御反転を実現するには、まずオブジェクト情報を取得する必要があります.したがって、XML解析ツールを使ってプロファイルを解析することができます.
  • は、Springにおける構成情報を模倣する.各beanタグにおいてオブジェクト名とクラスパスを取得することができ、クラスパスがあれば、反射によってオブジェクトを具体化することができる.
  • が生成されたら、どこに保存されますか?私たちは後からgetBen()を通じて指定されたオブジェクトを取得する必要があるので、オブジェクトを実装した後、オブジェクトを容器に保存する必要があり、nameを通じてそのオブジェクトを取得することができます.したがって、私たちはmapを使用して、すでに実用化されたオブジェクトを記憶することができます.nameの値はkeyで、実用化対象はvalueです.
  • しかし、あるオブジェクトを実装する場合、このオブジェクトは他のオブジェクトに依存し、これらの依存関係を維持する必要があります.すなわち、注入に依存します.一般的な依存注入:属性注入、構造方法注入、自動注入の3つのタイプのため、異なる依存性の特性に応じて、実用化オブジェクトを解析する際に異なる注入戦略を採用することができます.
  • 属性注入:このクラスの属性オブジェクトは、インスタンス化されたオブジェクトのCLassオブジェクトによって取得され、mapからuserDaoによってインスタンス化された属性オブジェクトが取得され、注入されるように構成される.構造方法注入:構成を行うことによって、バンドパラメータの構造方法を維持する必要があるクラスで宣言するので、無参画構造関数が無効になります.属性注入とは違って、属性注入はデフォルトのコンストラクタによって直接的にオブジェクトの実用化が可能ですが、十分に賛美された方法が宣言されているので、無参構造法は起動できません.したがって、先に声明のパラメータオブジェクトであるuserDaoに基づいて帯域構造方法を作成し、この構造方法を利用してオブジェクトを実用化し、自動注入を行う必要があります.まず自動注入マークを入れる必要があります.ルートラベルを解析する時にbeansの属性を解析し、自動注入を宣言したかどうかを判定します.前の2つの入力方法は自動注入より優先度が高いためです.したがって、このオブジェクトに属性依存性がある場合は、2つの注入方式で実現できますが、前の2つの注入方式では依存関係が解決されていない場合は、自動注入によって依存性を維持することができます.自動注入はまた二つに分けられます.一つはタイプによって注入し、もう一つは名前によって注入します.タイプによって注入します.属性オブジェクトを取得すると、そのオブジェクトのタイプを取得し、その後、map容器を循環して、同じタイプのオブジェクトがあるかどうかを判断します.ここのタイプは同じオブジェクト実装インターフェースのタイプです.判断する時に技術を行う必要があります.二つの実現類が同じインターフェースを実現している可能性がありますので、二つ以上のものにマッチすると異常を投げます.ここでカスタマイズできます.名前注入によって、名前注入によって、対象の属性名またはsetter方法の名称を取得し、その後map容器を循環して、同じ名前があるかどうかを判断し、ある場合は注入します.ここでは同じ名前の属性オブジェクトが2つ存在しません.map容器に登録し、同じ名前があれば上書きします.
    • 注意:シミュレーションの過程において、標準状況だけを考慮する.Springの実用化対象の維持依存性において、依存するオブジェクトがまだ容器に登録されていない場合、Springは先に依存するオブジェクトを登録し、キャッシュに加入し、順次にオブジェクトを登録する際にはまずキャッシュにそのオブジェクトがあるかどうかを確認し、springでループ依存注入の解決方法は複雑であり、対象を実用化する際には、インスタンス化が完了していない場合は、あらかじめキャッシュにオブジェクトを露出します.ここで少し言及してください.興味のあるものはソースを読むことができます.
    プロジェクトのソースコードはgithubに委託されました.自分でダウンロードする必要があります.
    2.1 dao層インターフェースを作成する
    package com.lic.dao;
public interface UserDao {
    public void query();
}
    2.2 dao層実現類の作成
    package com.lic.dao;
public class UserDaoImpl implements UserDao{
    @Override
    public void query() {
        System.out.println("    ");
    }
}
    2.3 service層インターフェースを作成する
    package com.lic.service;

public interface UserService {
    public void query();
}
    2.4 service層実現クラスを作成する
    package com.lic.service;
import com.lic.dao.UserDao;
public class UserServiceImpl implements UserService {
    private UserDao userDao;
    private UserDao userDao1;
 
    //    
    /*public UserServiceImpl(UserDao userDao,UserDao userDao1) {
        this.userDao = userDao;
        this.userDao1 = userDao1;
    }*/
    
    public void query() {
        userDao.query();
        userDao1.query();
    }
}
    2.5プロファイルの作成
    2.6工場類を作成する
    package com.lic.spring;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.*;

public class BeanFactory {
    // ioc  ,        bean  
    Map map =new HashMap<>();
    //     
    public BeanFactory(String path){
        parseXml(path);
    }

    //             
    private void parseXml(String path){
        File file = new File(this.getClass().getResource("/").getPath()+"//"+path);
        //    dom4j jar 
        SAXReader reader = new SAXReader();
        try{
            //  dom4j      
            Document document = reader.read(file);
            //     
            Element elementRoot = document.getRootElement();

            //      ,   false
            boolean autowireFlag = false;
            String autowire = elementRoot.attribute("default-autowire").getValue();
            //         ,             (    ,                )
            if (autowire.trim().length() > 1) {
                autowireFlag = true;
            }

            //         
            for (Iterator beanFir = elementRoot.elementIterator(); beanFir.hasNext();) {
                /**
                 * setup1、     ,            
                 */
                Element elementChild = beanFir.next();
                //    bean  name   
                String attrName = elementChild.attribute("name").getValue();
                //    bean   class   
                String attrClass = elementChild.attribute("class").getValue();
                Class clazz = Class.forName(attrClass);

                /**
                 * setup2、      
                 *           （     property   。          ）
                 *       
                 */
                Object object = null;
                //         ,          
                List conObj = new ArrayList();
                //           ,            
                List conArgs = new ArrayList();
                //              , for           
                boolean haveConstructor = false;
                for (Iterator propertyFir = elementChild.elementIterator(); propertyFir.hasNext(); ) {
                    /*
                     *              
                     */
                    //      
                    Element propertyEle = propertyFir.next();
                    if (propertyEle.getName().equals("property")) {
                        System.out.println(attrName + "          ...");
                        //             
                        if (object == null)
                            object = clazz.newInstance();
                        //  name   
                        String proAttrName = propertyEle.attribute("name").getValue();
                        //  ref   
                        String proAttrRef = propertyEle.attribute("ref").getValue();
                        //               
                        Object objectRefObj = map.get(proAttrRef);
                        //         
                        Field property = clazz.getDeclaredField(proAttrName);
                        property.setAccessible(true);
                        property.set(object, objectRefObj);

                        /*
                         *              
                         */
                    } else if (propertyEle.getName().equals("constructor-arg") && object == null) {
                        System.out.println(attrName + "          ...");
                        haveConstructor = true;
                        //               
                        //  ref   
                        String conArgRef = propertyEle.attribute("ref").getValue();
                        //               
                        Object conArgRefObj = map.get(conArgRef);
                        conObj.add(conArgRefObj);
                        conArgs.add(conArgRefObj.getClass().getInterfaces()[0]);
                    } else if(object == null){
                        throw new CannotParseExecption("     ,    ...");
                    }
                }
                //              
                if (haveConstructor) {
                    Class[] args = new Class[conArgs.size()];
                    for (int i = 0; i < conArgs.size(); i++) {
                        args[i] = conArgs.get(i);
                    }
                    Constructor constructor = clazz.getConstructor(args);
                    object = constructor.newInstance(conObj.toArray());
                }

                //         ,   bean                ,       
                if (autowireFlag && object == null) {
                    /*
                     *             
                     */
                    if ("byType".equalsIgnoreCase(autowire)) {
                        //             
                        Field[] fields = clazz.getDeclaredFields();
                        for (Field field : fields) {
                            //         : com.lic.UserDao
                            String fieldClassName = field.getType().getName();
                            //     bean     
                            int countClass = 0;
                            //       bean  
                            Object tempObject = null;
                            //     class     map               ,         ,   
                            for (String key : map.keySet()) {
                                //  map           
                                String tempClassName = map.get(key).getClass().getInterfaces()[0].getName();
                                //    
                                if (fieldClassName.equals(tempClassName)) {
                                    countClass++;
                                    tempObject = map.get(key);
                                }
                            }
                            if (countClass > 1) {
                                //          ,     
                                throw new TooManyExpectClassrExecption("        ,       !");
                            } else {
                                System.out.println(attrName + "          ...");
                                //              
                                if (object == null)
                                    object = clazz.newInstance();
                                //     
                                field.setAccessible(true);
                                field.set(object, tempObject);
                            }
                        }

                        /*
                         *             
                         */
                    } else if ("byName".equalsIgnoreCase(autowire)) {
                        Field[] fields = clazz.getDeclaredFields();
                        for (Field field : fields) {
                            String fieldName = field.getName();
                            int countClass = 0;
                            for (String key : map.keySet()) {
                                if (fieldName.equalsIgnoreCase(key)) {
                                    // map key    ,             name
                                    System.out.println(attrName + "          ...");
                                    if (object == null)
                                        object = clazz.newInstance();
                                    field.setAccessible(true);
                                    field.set(object, map.get(key));
                                    break;
                                }
                            }
                        }
                    } else {
                        throw new CannotParseExecption("     ,    ...");
                    }
                }

                //   bean       ,         
                if(object == null){
                    object=clazz.newInstance();
                }
                //            
                map.put(attrName,object);

            }
        }catch(Exception e){
            e.printStackTrace();
        }

    }

    public Object getBean(String beanName){
        return map.get(beanName);
    }
}
    2.7カスタム異常
    package com.lic.spring;
public class CannotParseExecption extends RuntimeException{
    public CannotParseExecption(String msg) {
        super(msg);
    }
}

    package com.lic.spring;
public class TooManyExpectClassrExecption  extends RuntimeException{
    public TooManyExpectClassrExecption(String msg) {
        super(msg);
    }
}
    2.8試験方法の作成
    package com.lic.test;
import com.lic.service.UserService;
import com.lic.spring.BeanFactory;

public class SpringTest {
    public static void main(String[] args) {
        BeanFactory beanFactory = new BeanFactory("spring.xml");
        UserService userService = (UserService) beanFactory.getBean("userService");
        userService.query();
    }
}
    解析:dom 4 jでプロファイルを解析し、解析したオブジェクト情報を反射生成対象でmap容器に登録し、依存性を維持し、依存するメンテナンスには主に3種類があります.属性注入、構造方法注入、自動注入.生命が自動注入された後、自動注入の前に他の2種類の注入を使用したら、自動注入は使用されなくなります.
    下一篇:Springソースシミュレーションは注釈方式に基づくSpringIOC(アナログByType自動注入、ByName自動注入)
    Titaniumで多言語を実現します.