Detaillierte Erläuterung der Java-Programmierkonfigurationsideen – JavaEE-Tutorial

Dieser Artikel enthält hauptsächlich eine detaillierte Erklärung der Konfigurationsideen für die Java-Programmierung. Ich hoffe, dass er für Freunde hilfreich sein wird, die Java lernen.

Detaillierte Erklärung der Konfigurationsideen für die Java-Programmierung

Obwohl SpringBoot bietet viele hervorragende Starter, die uns bei der schnellen Entwicklung helfen. Aufgrund der Besonderheiten der tatsächlichen Produktionsumgebung müssen wir jedoch noch die Standardintegrationskonfiguration anpassen, um die Steuerbarkeit des Programms zu verbessern, obwohl Ihre Konfiguration möglicherweise nicht besser ist als die des offiziellen Starters . Letzte Woche wurde der Blog aus Arbeits- und Dekorationsgründen nicht normal aktualisiert. Ich befürchtete, dass das Stoppen der Aktualisierung die Leute faul machen würde, also habe ich mir etwas Zeit genommen und einen relativ einfachen Artikel geschrieben. Später werde ich über meine Erfahrungen vom Dekorationsanfänger bis zum Einstieg sprechen.

Technologie: Konfiguration, ComponentScan, PropertySource, EnableTransactionManagement, Bean, Value
Hinweis: Im Artikel wird nur der Konfigurationscode veröffentlicht, der vollständige Testcode ist auf Github Superior.
Quellcode: https://github.com/ITDragonBl...
Artikelverzeichnisstruktur:

1. Java-Programmierkonfiguration

Vor Spring 4.x wurde die XML-Konfiguration im Allgemeinen in der Grundkonfiguration von Anwendungen verwendet, und Anmerkungen wurden in der Geschäftslogik empfohlen. Aber nach Spring 4.x begannen die Beamten, die Java-Programmierkonfiguration anstelle der XML-Konfiguration zu verwenden. Welche Vor- und Nachteile haben diese beiden Konfigurationen?

Java-Programmierkonfiguration und XML-Konfiguration

Vorteile der XML-Konfiguration: Für uns Programmierer der älteren Generation (┬＿┬) ist XML sehr benutzerfreundlich, einfach zu verwenden, leicht zu erweitern und zu ändern Anwendungskonfigurationsparameter erfordern keine Neukompilierung.

Nachteile der XML-Konfiguration: Das Lesen und Parsen von Konfigurationsdateien nimmt Zeit in Anspruch, und XML-Konfigurationsdateien mit zu viel Inhalt erscheinen aufgebläht und unpraktisch zu verwalten.

Vorteile der Java-Programmierkonfiguration: Im Vergleich zur XML-Konfiguration ist ihre Struktur klarer und besser lesbar und es spart außerdem Zeit beim Parsen von XML.

Nachteile der Java-Programmierkonfiguration: Das Ändern der Anwendungskonfigurationsparameter erfordert eine Neukompilierung. Tatsächlich stellt dies kein großes Problem dar. Nachdem die Anwendungskonfiguration abgeschlossen ist, werden die Benutzer sie im Allgemeinen nicht nach Belieben ändern.

In Anbetracht der Tatsache, dass sowohl Spring4.x als auch SpringBoot die Verwendung der Java-Programmierkonfiguration empfehlen, sollten wir dem Trend der Zeit folgen. Sie müssen es jedoch nicht verwenden !

Java-Programmierkonfigurationsschritte

Schritt 1: Erstellen Sie eine Konfigurationsklasse, fügen Sie die Anmerkung „Configuration“ zum Klassennamen hinzu, informieren Sie Spring darüber, dass es sich um eine Konfigurationsklasse handelt und ihre Funktion einer XML-Datei ähnelt

Schritt 2: Laden Sie die externe Konfigurationsdatei, fügen Sie die Annotation PropertySource zum Klassennamen hinzu und geben Sie den Lesepfad der Eigenschaftendatei an

Schritt 3: Holen Sie sich den Eigenschaftswert der Anwendungskonfiguration und fügen Sie ihn hinzu Geben Sie den Annotation-Wert an die Eigenschaftsvariable an und übergeben Sie den ${}-Ausdruck, um die Parameter in der Konfigurationsdatei abzurufen

Schritt 4: Abhängigkeitsinjektion, fügen Sie der Methode Bean-Annotationen hinzu. Sie können auch FactoryBean verwenden

Die Syntax des ersten und vierten Schritts. Im zweiten Teil des Artikels wird sie ausführlich vorgestellt. Die Syntax des zweiten und dritten Schritts wird im dritten Teil des Artikels ausführlich vorgestellt.

import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import com.mchange.v2.c3p0.ComboPooledDataSource;

/**
 * Spring 配置类
 * 配置数据源，事务管理，bean，自动扫描包
 * @author itdragon
 */
@Configuration    // 声明该类为配置类
@PropertySource({"classpath:propertySource.properties"})    // 引入外部文件
@ComponentScan("com.itdragon")    // 配置自动扫描包的路径
@EnableTransactionManagement    // 开启基于注解的事务管理功能
public class ApplicationContextConfig {
    
    @Value("${DATA_USER}")
    private String DATA_USER;
    
    @Value("${DATA_PAWD}")
    private String DATA_PAWD;
    
    @Value("${DATA_DRIVER}")
    private String DATA_DRIVER;
    
    @Value("${DATA_JDBC_URL}")
    private String DATA_JDBC_URL;
    
    @Bean // 数据源
    public DataSource dataSource() throws Exception{
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(DATA_USER);
        dataSource.setPassword(DATA_PAWD);
        dataSource.setDriverClass(DATA_DRIVER);
        dataSource.setJdbcUrl(DATA_JDBC_URL);
        return dataSource;
    }
    
    @Bean // jdbc模板
    public JdbcTemplate jdbcTemplate() throws Exception{
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource());
        return jdbcTemplate;
    }
    
    @Bean // 事务管理
    public PlatformTransactionManager transactionManager() throws Exception{
        return new DataSourceTransactionManager(dataSource());
    }

}

Transaktionsklasse

import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.itdragon.dao.ITDragonDao;

@Service
public class ITDragonServer {
    
    @Autowired(required=false)
    private ITDragonDao itdragonDao;

    public List<Map<String,Object>> findAll() {
        return itdragonDao.findAll();
    }
    
    @Transactional
    public void updateNameById(String name, Long id) {
        itdragonDao.updateUserNameById(name, id);
        System.out.println(0/0); // 事务异常
    }
}

Für vollständigen Code bitte asynchrones Github

2. Komponenteninjektion

Bean-Annotation ähnelt -Tag der XML-Datei, in dem der durch die Bean-Annotation geänderte Methodenname der ID im 60e23eb984d18edbb092da6b8f295aba-Tag entspricht. Der Wert der ID kann auch über das Value-Attribut der Bean-Annotation festgelegt werden. Es wird häufig im zugrunde liegenden Code von SpringBoot verwendet. 60e23eb984d18edbb092da6b8f295aba

Wenn Sie möchten, dass das Objekt nach dem Start des Containers erstellt und nach der Verwendung direkt aus dem Container abgerufen wird, müssen Sie nichts tun, da Spring standardmäßig eine einzelne Instanz, also das Objekt, ist wird erstellt, nachdem der Container gestartet und im Container gespeichert wurde, und ruft ihn dann aus dem Container ab, wenn er verwendet wird.

Wenn Sie möchten, dass der Container kein Objekt nach dem Start erstellt, sondern es erstellt, wenn es verwendet wird, es dann im Container speichert und es dann bei der nächsten Verwendung aus dem Container abruft , Sie können es durch Lazy Loading implementieren, also Lazy Annotation Grooming verwenden.

Wenn Sie möchten, dass der Container nach dem Start kein Objekt erstellt, sondern bei jeder Verwendung, verwenden Sie die Multi-Instanz-Methode, d. h. die Scope-Annotation und den Wert von Der Parameter ist Prototyp, also @Scope("prototype") .

Wenn Sie die Beans auswählen möchten, die basierend auf den Bedingungen nach dem Start des Containers injiziert werden müssen, können Sie die Annotation Conditional verwenden, um zu beurteilen, ob die zugrunde liegende Auswertung von SpringBoot diese Annotation verwendet.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Controller;
import com.itdragon.entity.ITDragonEntity;
import com.itdragon.server.ITDragonServer;

/**
 * 知识点二：配置自动扫描包路径
 * 一、注解ComponentScan的value值设置自动扫描包的路径
 * 二、注解ComponentScan的excludeFilters值设置扫描排除的规则
 *     1)、通过注解@Filter设置排除的类型,type=ANNOTATION表示按照注解包含排除。classes是具体的注解，如Controller,Server,Repository
 * 三、注解ComponentScan的includeFilters值设置扫描加入的规则
 *  1)、通过设置useDefaultFilters=false关闭Spring默认扫描全部的功能，使includeFilters生效
 *  
 * 知识点三：@Filter常用的拦截类型
 * 一、FilterType.ANNOTATION：按照注解
 * 二、FilterType.ASSIGNABLE_TYPE：按照给定的类型，包括其子类和实现类
 * 三、FilterType.CUSTOM：使用自定义规则
 * 
 * 第一个ComponentScan注解表示在指定包下不扫描通过Controller注解修饰的类和ITDragonServer类及其子类和实现类
 * 第二个ComponentScan注解表示在指定包下只扫描通过Controller注解修饰的类
 * 第三个ComponentScan注解表示在指定包下根据自定义拦截规则，不扫描满足规则的类
 */
@Configuration
@ComponentScan(value="com.itdragon",excludeFilters={@Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
        @Filter(type=FilterType.ASSIGNABLE_TYPE,classes={ITDragonServer.class})})
//@ComponentScan(value="com.itdragon",includeFilters={@Filter(type=FilterType.ANNOTATION,classes={Controller.class})},useDefaultFilters=false)
//@ComponentScan(value="com.itdragon",excludeFilters={@Filter(type=FilterType.CUSTOM,classes={ITDragonCustomTypeFilter.class})})
public class ITDragonConfig {
    
    /**
     * 知识点一：配置bean
     * 一、注解Bean的value值表示bean的id
     * 二、注解Bean的value值未设置，则方法名表示bean的id
     */
    @Bean(value="itdragonBean")
    public ITDragonEntity itdragonEntity() { //方法名很重要，类似xml的id名，也可以通过@bean的value值重定义
        return new ITDragonEntity("itdragon", "configuration-password", 25);
    }
    
    /**
     * 知识点四：Scope属性
     * @Scope，调整作用域，默认单实例
     * singleton：单实例：ioc容器启动后创建对象放到ioc容器中，需要是从容器中获取。
     * prototype：多实例：ioc容器启动后每次获取对象时都要创建对象。
     * request：同一次请求创建一个实例
     * session：同一个session创建一个实例
     * 
     * 知识点五：懒加载
     * 针对单实例而言，在容器启动后不创建对象，在第一次使用Bean时创建对象。可以理解为单实例的一种补充。
     * 
     */
//    @Scope("prototype")
    @Lazy
    @Bean
    public ITDragonEntity scopeTopicBean() {
        System.out.println("^^^^^^^^^^^^^^^^^^^^^Create Bean");
        return new ITDragonEntity("scopeBean", "singleton-prototype-request-session", 25);
    }
    
    /**
     * 知识点六：Conditional条件判断
     * 满足条件才会注册bean，可以修饰在类上，管理整个类下的组件注入。
     */
    @Bean
    @Conditional({ITDragonCustomCondition.class})
    public ITDragonEntity conditionalBean() {
        return new ITDragonEntity("conditionalBean", "Conditional-Condition-CustomCondition", 25);
    }
    
    /**
     * 知识点七：FactoryBean工厂Bean
     * FactoryBean默认通过调用getObject创建的对象，通过调用isSingleton设置单实例和多实例。
     */
    @Bean
    public ITDragonFactoryBean itdragonFactoryBean() {
        return new ITDragonFactoryBean();
    }
}

Angepasste bedingte Beurteilungskomponenten-Injektionsklasse

import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

/**
 * 自定义的条件判断组件注入
 * @author itdragon
 *
 */
public class ITDragonCustomCondition implements Condition{

    /**
     * 判断注册的bean中是否含有指定的bean
     */
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 获取bean的注册类
        BeanDefinitionRegistry registry = context.getRegistry();
        return registry.containsBeanDefinition("scopeTopicBean"); // 有则加载conditionalBean
    }

}

Angepasste Bean-Factory-Klasse

import org.springframework.beans.factory.FactoryBean;
import com.itdragon.entity.ITDragonEntity;
/**
 * 自定义Bean的工厂类
 * @author itdragon
 *
 */
public class ITDragonFactoryBean implements FactoryBean<ITDragonEntity>{

    public ITDragonEntity getObject() throws Exception {
        System.out.println("^^^^^^^^^^^^^^^^^^^^^FactoryBean Create Bean");
        return new ITDragonEntity(); // 创建对象并返回到容器中
    }

    public Class<?> getObjectType() {
        return ITDragonEntity.class;
    }

    public boolean isSingleton() {
        return false; // 设置多实例,true则为单例
    }

}

3. Attributzuweisung

Eigenschaftszuweisungsschritte :

Schritt 1: Externe Dateien über die Annotation PropertySource einführen. Wenn Sie befürchten, dass die Datei nicht existiert, können Sie sie ignorieren, indem Sie den Parameter „ignoreResourceNotFound“ festlegen. Schritt 2: Rufen Sie den Wert aus der externen Datei über die Annotation „Value“ ab ${}-Format und unterstützt auch #{}. SpEL-Ausdrücke können auch direkt als Zeichenfolgen übergeben werden. Wenn Sie komplexe Werte wie Sammlungen erhalten möchten, können Sie die Annotation ConfigurationProperties verwenden. Die Vor- und Nachteile beider werden später ausführlich vorgestellt.

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import com.itdragon.entity.ITDragonEntity;

/**
 * 知识点一： 引入外部文件，并从文件中获取值
 * @PropertySource 引入外部文件，支持多个，如果文件不存在会报错，可以通过设置参数ignoreResourceNotFound=true忽略
 * @Value 从外部文件中获取值，支持spel表达式，#{},${},string
 * @author itdragon
 */
@Configuration
@PropertySource(value={"classpath:propertySource.properties","classpth:xxx.properties"},ignoreResourceNotFound=true)
public class ITDragonConfigValue {
    
    @Value("${ACCOUNT}")        // 从配置文件获取数据
    private String ACCOUNT;
    
    @Value("${PASSWORD}")
    private String PASSWORD;
    
    @Value("${AGE}")
    private Integer AGE;
    
    @Value("ITDragon")            // 普通赋值
    private String str;
    
    @Value("#{(1+2-3)/4*5}")    // 算术运算
    private String operator;
    
    @Value("#{1>2 || 2 <= 3}")    // 关系运算
    private Boolean comparison;
    
    @Value("#{systemProperties[&#39;java.version&#39;]}") // 系统配置：os.name
    private String systemProperties;
    
    @Value("#{T(java.lang.Math).abs(-18)}")    // 表达式
    private String mapExpression;
    
    @Bean("valueBean")
    public ITDragonEntity itdragonEntity() {
        System.out.println("^^^^^^^^^^^^^^^^^^^^ str : " + str);
        System.out.println("^^^^^^^^^^^^^^^^^^^^ operator : " + operator);
        System.out.println("^^^^^^^^^^^^^^^^^^^^ comparison : " + comparison);
        System.out.println("^^^^^^^^^^^^^^^^^^^^ systemProperties : " + systemProperties);
        System.out.println("^^^^^^^^^^^^^^^^^^^^ mapExpression : " + mapExpression);
        return new ITDragonEntity(ACCOUNT, PASSWORD, AGE);
    }

}

四、闲谈学习

这里并不是介绍如何学习一门技术，而是论养成一个学习习惯的重要性。大一时期，因为担心找不到工作而报了一个线上培训机构。经常被洗脑，其中一句话而我印象深刻 ---- "让优秀成为一种习惯"。听得我热血沸腾。花了五六千大洋报名，后来才发现网上有免费的。。。。个人不建议参加培训。

这钱花的还算值得，"让优秀成为一种习惯"，这句话对我的影响很大，从大学到工作，每当遇到陌生的知识，并没有选择逃避它。而是抽时间从网上找资料，去学习，整理，实践直到弄懂它。可我万万没有想到，这种学习的精神竟然用到了装修上。。。。可能学习已经是我的一个习惯了吧！

开始，我是一个装修小白，不知道什么是全包、半包、清包；不知道什么是硬装、软装；也不知道装修的流程；不知道水电线、橱柜、洁具的品牌选择，不知道挂机、柜机、风管机、中央空调的优缺点；不知道封阳台的利弊；更不知道一个装修效果图要七八千。面对这些未知的领域，我寸步难行。我清楚的知道：如果你不懂，你就是砧板上的鱼肉，任人宰割。

现在，我通过在百度，知乎，兔巴兔等平台上找答案，并把内容用Markdown的格式整理！我都被自己吓到了。不仅如此，我还在抢设计师的饭碗，自己动手设计效果图。在制作效果图的过程中，发现了很多不合理的设想。庆幸问自己设计了一套效果图，不然又有很多无用功，耗时，耗力，耗钱。爸妈和女票就是客户，而我就一直处于改！改！改！的阶段。体验了一把前端工程师的辛酸。

我是谁？我在哪？我在做什么？

我是一名程序员，我在学习的道路上，我在做能提高自己的事情！

相关推荐：

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Java-Programmierkonfigurationsideen – JavaEE-Tutorial. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!