הערות Spring

לְהַגִּיב על התרגום שלך, אני צריך לבדוק את הטקסט בקפיצים קטנים. אנא המתן לקצת זמן.

הערות קפיצה

• הערכת המסגרת יישום וקידום רעיון של שליטה ההפוכה (IOC) או הזרמת תלות (DI) ולמעשה היא תיק יישום IOC.
• באופן מסורתי, Spring מאפשר למפתח לנהל תלות בין חוטים באמצעות הגדרות מבוססות XML.
• קיים דרך אחרת להגדיר פולי ותלות ביניהם. שיטה זו היא הגדרת Java-בהתבסס על קונפיגורציה.
• בניגוד לגישה ב-XML, הקונפיגורציה בהתבסס על Java מאפשרת לך לנהל רכיבי פולי באופן פרוגרמטי. זו הסיבה שבזכותה הוזנו הערות קפיצה של Spring.

במאמר זה נבדוק את ההערות של Spring הכי נפוצות ונסתכל על דוגמאות תכנית.

רשימת הערות של Spring

חלק מההערות המרכזיות של מסגרת ה- spring core הן:

1. @Configuration: משמש לציון שכיתה מציינת שיש לה שיטה אחת או יותר @Bean. כלולות אלו מעובדות על ידי המסגרת של Spring ליצירת הגדרות פולים ובקשות לשירות לאלו הפולים בזמן ריצה.

2. @Bean: מציין כי מתודה מייצרת bean שינוהל על ידי מיכל ה-Spring. זו אחת מהאנוטציות החשובות והנפוצות ביותר ב-Spring. אנוטציית @Bean יכולה גם להשתמש עם פרמטרים כמו name, initMethod ו-destroyMethod.

   • name – מאפשר לתת שם ל-bean
   • initMethod – מאפשר לבחור מתודה שתזומן בעת רישום ה-context
   • destroyMethod – מאפשר לבחור מתודה שתזומן בעת כיבוי ה-context

   לדוגמא:

   @Configuration
   public class AppConfig {
   
       @Bean(name = "comp", initMethod = "turnOn", destroyMethod = "turnOff")
       Computer computer(){
           return new Computer();
       }
   }
   

   public class Computer {
   
       public void turnOn(){
           System.out.println("טוען מערכת הפעלה");
       }
       public void turnOff(){
           System.out.println("סוגר כל התוכניות");
       }
   }
   

3. @PreDestroy ו־@PostConstruct הם אופציות אלטרנטיביות ל-initMethod ו־destroyMethod של הבונה (bean). ניתן להשתמש בהם כאשר מדובר במחלקת הבונה שלנו. לדוגמה;

    public class Computer {
   
       @PostConstruct
       public void turnOn(){
           System.out.println("טוען מערכת הפעלה");
       }
   
       @PreDestroy
       public void turnOff(){
           System.out.println("סוגר כל התוכניות");
       }
   }
   

4. @ComponentScan: מגדיר הזמנות לסריקת רכיבים לשימוש עם קלסים @Configuration. כאן ניתן לציין את החבילות הבסיסיות לסריקה של רכיבי Spring.

5. @Component: מציין כי קלס שמוסתמך הוא "רכיב". כאשר משתמשים בהגדרה מבוססת על אנוטציות וסריקת מסלול, קלסים כאלו נחשבים כמועמדים לאוטומטית.

6. @PropertySource: מספק גרם דקלרטיבי ופשוט להוספת מקור מאפיינים לסביבת Spring. ישנה הערכה דומה להוספת מערך של קבצי מקורות i.e @PropertySources.

7. @Service: מציין כי כיתה שמסומנת היא "שירות". האנוטציה הזו משמשת כהתמחות של @Component, ומאפשרת לכיתות ביצוע להיזהות באופן אוטומטי דרך סריקת classpath.

8. @Repository: מציין כי כיתה שמסומנת היא "מאגר נתונים". האנוטציה הזו משמשת כהתמחות של @Component ומומלץ לשימוש יחד עם כיתות DAO.

9. @Autowired: האנוטציה @Autowired של Spring משמשת להזרקה אוטומטית של חומרות. האנוטציה @Qualifier של Spring משמשת בשילוב עם Autowired כדי למנוע תחושת בלבול כאשר יש לנו שני או יותר חומרות מוגדרים עבור אותו סוג.

אנוטציות MVC של Spring

חלק מהאנוטציות החשובות של MVC של Spring הן:

1. @Controller
2. @RequestMapping
3. @PathVariable
4. @RequestParam
5. @ModelAttribute
6. @RequestBody וְ @ResponseBody
7. @RequestHeader וְ @ResponseHeader

ניתן למצוא מידע נוסף עליהם ב- מדריך ל- Spring MVC.

אננוטציות ניהול עסקאות ב- Spring

@Transactional היא אננוטציה לניהול עסקאות הקבועה של Spring, ניתן לקרוא עוד ב- Spring MVC Hibernate.

אננוטציות אבטחת Spring

@EnableWebSecurity משמש עם כיתת @Configuration כדי להגדיר את התצורה של Spring Security, קרא עוד ב- דוגמת Spring Security.

אננוטציות Spring Boot

1. @SpringBootApplication
2. @EnableAutoConfiguration

קרא עוד ב- דוגמת Spring Boot.

דוגמת אננוטציות Spring

בואו נסתכל על דוגמה פשוטה בה נשתמש באננוטציות של Spring באפליקציה שלנו. התמונה למטה ממחישה את פרויקט הדוגמה שלי עם אננוטציות של Spring.

תלויות הסביבה של המסגרת של Spring

I have created the maven project and added Spring Core Framework dependencies.

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.journaldev.spring</groupId>
	<artifactId>spring-annotations</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>Spring Annotations</name>

	<properties>
		<spring.framework>4.3.0.RELEASE</spring.framework>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.framework}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.framework}</version>
		</dependency>

	</dependencies>

</project>

זה יוביל להורדת כל קובצי ה- core של Spring לפרויקט שלנו.

מחלקות רכיב

השלב הבא הוא ליצור מחלקות רכיב. כאן אני מעצב רכיבי מסד נתונים מרובים, אחד עבור MySQL ואחד עבור Oracle. `

package com.journaldev.drivers;

public interface DataBaseDriver {
    public String getInfo();
}

` `DataBaseDriver` הוא ה-`interface` הבסיסי שנקלוט. `

package com.journaldev.drivers;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Component
@PropertySource("classpath:mysqldatabase.properties")
public class MySqlDriver implements DataBaseDriver {

    @Value("${databaseName}")
    private String databaseName;
    @Value("${disableStatementPooling}")
    private String disableStatementPooling;

    public String getInfo() {
        return "[ Driver: mySql" +
                ", databaseName: " + databaseName +
                ", disableStatementPooling: " + disableStatementPooling +
                " ]";
    }
}

` שים לב לשימוש באנוטציה `@Component` כדי לציין למערכת הפריימוורק של Spring להתייחס למחלקה זו כרכיב. אנו גם משתמשים באנוטציות `@PropertySource` ו־`@Value`, Spring תשתמש בהן בזמן ריצה כדי להכניס ולהגדיר את ערכי המשתנים מקובץ התכונות המסוים. להלן המאפיינים המוגדרים בקובץ `mysqldatabase.properties`. `

databaseName=school
disableStatementPooling=true

package com.journaldev.drivers;

public class OracleDriver implements DataBaseDriver {

    protected String url;
    protected String user;
    protected String password;
    protected String driver;
    protected Integer port;


    public String getUrl() {
        return url;
    }

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getDriver() {
        return driver;
    }

    public void setDriver(String driver) {
        this.driver = driver;
    }

    public Integer getPort() {
        return port;
    }

    public void setPort(Integer port) {
        this.port = port;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getInfo() {
        return "[ Driver: Oracle" +
                ", url: " + url +
                ", port; " + port +
                ", user: " + user +
                ", password: " + password  +
                ", driver: " + driver +
                " ] ";
    }
}

` `OracleDriver` הוא גרעין פשוט, נשתמש במחלקת שירות כדי להכניס תכונות לגרעין זה. `

` מחלקת שירות של Spring `

package com.journaldev.service;

import com.journaldev.drivers.DataBaseDriver;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    @Qualifier("oracleDriver")
    private DataBaseDriver dataBaseDriver;

    public String getDriverInfo(){
        return dataBaseDriver.getInfo();
    }
}

` כאן אנו משתמשים באנוטציה `@Service` כדי לציין למערכת הפריימוורק של Spring להתייחס אליה כמחלקת שירות. לאחר מכן אנו משתמשים באנוטציות `@Autowired` ו־`@Qualifier("oracleDriver")` כדי לספר למערכת הפריימוורק של Spring להכניס את הגרעין בשם `oracleDriver` למאפיין המחלקה `dataBaseDriver`. שים לב שעדיין לא יצרנו את הגרעין של Spring הזה. `

` גרעיני Spring `

` השלב הסופי הוא ליצור את גרעיני Spring שלנו ומחלקות הקונפיגורציה כדי להדביק את הכל יחד. `

package com.journaldev.config;

import org.springframework.beans.factory.annotation.Autowired;
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.core.env.Environment;

import com.journaldev.drivers.DataBaseDriver;
import com.journaldev.drivers.MySqlDriver;
import com.journaldev.drivers.OracleDriver;

@Configuration
@ComponentScan("com.journaldev")
@PropertySource("classpath:oracledatabase.properties")
public class AppConfig {

	@Autowired
        Environment environment;
	
	@Bean
	DataBaseDriver oracleDriver() {
        OracleDriver oracleDriver = new OracleDriver();
	oracleDriver.setDriver(environment.getProperty("db.driver"));
        oracleDriver.setUrl(environment.getProperty("db.url"));
        oracleDriver.setPort(Integer.parseInt(environment.getProperty("db.port")));
        oracleDriver.setUser(environment.getProperty("db.user"));
        oracleDriver.setPassword(environment.getProperty("db.password"));

        return oracleDriver;

	}

	@Bean
	DataBaseDriver mysqlDriver() {
		return new MySqlDriver();
	}
}

` שים לב להגדרת הגרעין עבור `oracleDriver`. בשיטה זו, אנו קוראים תכונות מקובץ `oracledatabase.properties` שמוגדרות כמשתנה `environment` על ידי מערכת הפריימוורק של Spring. הנה המאפיינים המוגדרים בקובץ `oracledatabase.properties`.

db.url=localhost
db.port=4444
db.user=vasiliy
db.password=yilisav
db.driver=driver_name

הפרוייקט הדוגמא של הערות האביב שלנו מוכן לבדיקה. כסיכום, ביצענו את השלבים הבאים:

1. יצרנו פרוייקט Maven והוספנו תלויות Spring נדרשות.
2. יצרנו מחלקות רכיב וכניסת מאפיינים מקובץ משאבים אל המשתנה שלו.
3. אם יש לנו רכיב צד שלישי, אנו יכולים להשתמש במחלקת Service כדי להכניס תלויות אליו. בדיוק כמו שעשינו עבור OracleDriver דרך מחלקת UserService.
4. לבסוף, יצרנו מחלקת הגדרה כדי להגדיר את השקעי האביב ולהגדיר את תיק חבילה לסרוק עבור מחלקות רכיב Spring ולתצור אותם.

בדיקת דוגמאות הערות האביב

כאן הוא מחלקת הראשית שלנו לבדיקת הדוגמא של הערות האביב שלנו.

package com.journaldev;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;

import com.journaldev.config.AppConfig;
import com.journaldev.drivers.DataBaseDriver;
import com.journaldev.service.UserService;

public class Main {
	public static void main(String[] args) {
	AbstractApplicationContext appContext = new AnnotationConfigApplicationContext(AppConfig.class);

	DataBaseDriver oracle = appContext.getBean("oracleDriver", DataBaseDriver.class);
	DataBaseDriver mysql = appContext.getBean("mysqlDriver", DataBaseDriver.class);
		
        System.out.println("Oracle driver info:");
        System.out.println(oracle.getInfo());
        
        System.out.println("MySQL driver info:");
        System.out.println(mysql.getInfo());

        System.out.println("UserService Information");
	UserService userService = appContext.getBean(UserService.class);
	System.out.println(userService.getDriverInfo());

	appContext.close();
	}
}

התמונה למטה מציגה את הפלט שנוצר. שימו לב שלא הגדרנו שום מסגרת רישום, לכן כל הרישום של המסגרת של Spring מתובצע בצבע אדום בקונסול.
זו הכל להקדמה קצרה להערות האביב. רשמתי כאן רוב ההערות החשובות, אך ישנם עוד הרבה מהן למשימות ספציפיות. ניתן להוריד את פרוייקט הדוגמא של הערות האביב שלי מהקישור למטה.

הורד הורד דוגמה לפרויקט הערות Spring

הפניה: מסמך API