spring チュートリアル
春を始めよう

備考

バージョン

セットアップ（XML構成）

Hello Springを作成する手順：

0. Spring Bootを調べて、それがあなたのニーズに合っているかどうかを確認してください。
1. プロジェクトに正しい依存関係を設定してください。 MavenまたはGradleを使用することをお勧めします。
2. POJOクラスを作成します（例： Employee.java
3. クラスと変数を定義できるXMLファイルを作成します。例： beans.xml
4. メインクラス、例えばCustomer.java作成します
5. Spring Bean （およびその推移的な依存関係）を依存関係として含めます。

Employee.java ：

package com.test;

public class Employee {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void displayName() {
        System.out.println(name);
    }
}

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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
        
    <bean id="employee" class="com.test.Employee">
        <property name="name" value="test spring"></property>
    </bean>

</beans>

Customer.java ：

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Customer {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

      Employee obj = (Employee) context.getBean("employee");
      obj.displayName();
   }
}

例によるコアスプリング機能の紹介

説明

これは、/ showcasingを含む自己完結的な実行例です：必要最小限の依存関係 、Java 設定 、アノテーションとJava設定によるBean宣言 、コンストラクターとプロパティによる依存関係注入 、 プリ/ポストフック。

依存関係

これらの依存関係はクラスパスで必要です。

1. スプリングコア
2. 春の文脈
3. 春豆
4. 春の
5. ばね式
6. コモンズロギング

メインクラス

最後から、これはMainクラスのメインクラスで、 main()メソッドのプレースホルダとして機能し、Configurationクラスをポイントしてアプリケーションコンテキストを初期化し、特定の機能を示すために必要なさまざまなBeanをすべて読み込みます。

package com.stackoverflow.documentation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;



public class Main {

    public static void main(String[] args) {

        //initializing the Application Context once per application.
        ApplicationContext applicationContext = 
                new AnnotationConfigApplicationContext(AppConfig.class);

        //bean registered by annotation
        BeanDeclaredByAnnotation beanDeclaredByAnnotation = 
                applicationContext.getBean(BeanDeclaredByAnnotation.class);
        beanDeclaredByAnnotation.sayHello();

        //bean registered by Java configuration file
        BeanDeclaredInAppConfig beanDeclaredInAppConfig = 
                applicationContext.getBean(BeanDeclaredInAppConfig.class);
        beanDeclaredInAppConfig.sayHello();

        //showcasing constructor injection
        BeanConstructorInjection beanConstructorInjection = 
                applicationContext.getBean(BeanConstructorInjection.class);
        beanConstructorInjection.sayHello();

        //showcasing property injection
        BeanPropertyInjection beanPropertyInjection = 
                applicationContext.getBean(BeanPropertyInjection.class);
        beanPropertyInjection.sayHello();

        //showcasing PreConstruct / PostDestroy hooks
        BeanPostConstructPreDestroy beanPostConstructPreDestroy = 
                applicationContext.getBean(BeanPostConstructPreDestroy.class);
        beanPostConstructPreDestroy.sayHello();
    }
}

アプリケーション構成ファイル

構成クラスは@Configurationによって注釈が付けられ、初期化されたアプリケーションコンテキストのパラメータとして使用されます。コンフィグレーションクラスのクラスレベルの@ComponentScanアノテーションは、アノテーションを使用して登録されたBeanおよび依存関係をスキャンするパッケージを指します。最後に、 @Beanアノテーションは、コンフィグレーションクラスのBean定義として機能します。

package com.stackoverflow.documentation;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.stackoverflow.documentation")
public class AppConfig {

    @Bean
    public BeanDeclaredInAppConfig beanDeclaredInAppConfig() {
        return new BeanDeclaredInAppConfig();
    }
}

アノテーションによるBean宣言

@Componentアノテーションは、POJOをコンポーネントのスキャン中に登録できるSpring Beanとして画定します。

@Component
public class BeanDeclaredByAnnotation {

    public void sayHello() {
        System.out.println("Hello, World from BeanDeclaredByAnnotation !");
    }
}

アプリケーション構成によるBean宣言

Beanの宣言/定義がApplication Configurationクラスファイル内で発生しているため、POJOに注釈を付けたり、マークする必要はありません。

public class BeanDeclaredInAppConfig {

    public void sayHello() {
        System.out.println("Hello, World from BeanDeclaredInAppConfig !");
    }
}

コンストラクタインジェクション

@Autowiredアノテーションはコンストラクタレベルで設定されていることに注意して@Autowired 。明示的に名前で定義されない限り、デフォルトのBeanToBeInjectedはBean のタイプ （この例ではBeanToBeInjected ）に基づいて行われます。

package com.stackoverflow.documentation;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BeanConstructorInjection {

    private BeanToBeInjected dependency;

    @Autowired
    public BeanConstructorInjection(BeanToBeInjected dependency) {
        this.dependency = dependency;
    }

    public void sayHello() {
        System.out.print("Hello, World from BeanConstructorInjection with dependency: ");
        dependency.sayHello();
    }
}

プロパティインジェクション

@Autowiredアノテーションは、JavaBeans標準に準拠する名前を持つセッターメソッドを定義しています。

package com.stackoverflow.documentation;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BeanPropertyInjection {

    private BeanToBeInjected dependency;

    @Autowired
    public void setBeanToBeInjected(BeanToBeInjected beanToBeInjected) {
        this.dependency = beanToBeInjected;
    }

    public void sayHello() {
        System.out.println("Hello, World from BeanPropertyInjection !");
    }
}

PostConstruct / PreDestroyフック

私たちは、によってビーンの初期化と破壊を傍受することができ@PostConstructと@PreDestroyフック。

package com.stackoverflow.documentation;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class BeanPostConstructPreDestroy {

    @PostConstruct
    public void pre() {
        System.out.println("BeanPostConstructPreDestroy - PostConstruct");
    }

    public void sayHello() {
        System.out.println(" Hello World, BeanPostConstructPreDestroy !");
    }

    @PreDestroy
    public void post() {
        System.out.println("BeanPostConstructPreDestroy - PreDestroy");
    }
}

Spring Frameworkとは何ですか、なぜそれをどうしたらいいですか？

Springはクラスの束を提供するフレームワークです。これを使用すると、コードにボイラープレートロジックを記述する必要がないため、SpringはJ2ee上に抽象レイヤーを提供します。

単純なJDBCアプリケーションの例については、プログラマーが

1. ドライバクラスの読み込み
2. 接続の作成
3. 文オブジェクトの作成
4. 例外の処理
5. クエリの作成
6. クエリの実行
7. 接続を閉じる

これは、すべてのプログラマーが同じコードを書くので、定型コードとして扱われます。したがって、簡単にするためにフレームワークは定型ロジックを処理し、プログラマはビジネスロジックのみを記述する必要があります。したがって、Springフレームワークを使用することで、最小限のコード行でプロジェクトを迅速に開発でき、バグもなく、開発コストと時間も削減できます。

だから、ストラットとして春を選ぶ理由はそこにあります

ストラットは、ウェブの側面のみに解決策を提供するフレームワークであり、ストラットは本質的に侵襲的です。 SpringにはStrutsよりも多くの機能がありますので、Springを選択する必要があります。

1. Springは本質的に非侵襲的です。つまり、クラスを拡張したり、クラスにインターフェイスを実装したりする必要はありません。
2. Springは汎用性があります。つまり、プロジェクト内の既存のテクノロジーと統合できます。
3. Springはエンドツーエンドのプロジェクト開発を提供します。つまり、ビジネスレイヤ、パーシスタンスレイヤのようなすべてのモジュールを開発できます。
4. 春は軽量です：つまり、特定のモジュールで作業したい場合は、完全な春を学ぶ必要はなく、その特定のモジュール（例：Spring Jdbc、Spring DAO）
5. Springは依存性注入をサポートしています。
6. Springは、 複数のプロジェクト開発（コアJavaアプリケーション、Webアプリケーション、分散アプリケーション、エンタープライズアプリケーション）をサポートしています。
7. Springは、クロスカッティングに関するアスペクト指向プログラミングをサポートしています。

最後に、SpringがStrutsに代わるものだと言えるでしょう。しかし、SpringはJ2EE APIを置き換えるものではありません.Springが提供するクラスは内部的にJ2EE APIクラスを使用しています。 Springは膨大なフレームワークなので、いくつかのモジュールに分かれています。モジュールはSpring Core以外のモジュールに依存しません。いくつかの重要なモジュールは

1. スプリングコア
2. Spring JDBC
3. 春AOP
4. 春の取引
5. スプリングORM
6. Spring MVC