Shënime pranverore

Spring Annotations na lejon të konfigurojmë varësitë dhe të zbatojmë injeksionin e varësisë përmes programeve java.

Shënime pranverore

  • Spring frame zbaton dhe promovon parimin e përmbysjes së kontrollit (IOC) ose injektimit të varësisë (DI) dhe në fakt është një kontejner IOC.
  • Tradicionalisht, Spring lejon një zhvillues të menaxhojë varësitë e bean duke përdorur konfigurimin e bazuar në XML.
  • Ekziston një mënyrë alternative për të përcaktuar fasulet dhe varësitë e tyre. Kjo metodë është një konfigurim i bazuar në Java.
  • Ndryshe nga qasja XML, konfigurimi i bazuar në Java ju lejon të menaxhoni komponentët e bean në mënyrë programore. Kjo është arsyeja pse u prezantuan shënimet e pranverës.

Në këtë artikull ne do të eksplorojmë Annotimet e Pranverës më të përdorura dhe gjithashtu do të shohim disa programe shembull.

Lista e shënimeve të pranverës

Disa nga shënimet e kornizës bazë të pranverës janë:

  1. @Configuration: Used to indicate that a class declares one or more @Bean methods. These classes are processed by the Spring container to generate bean definitions and service requests for those beans at runtime.

  2. @Bean: Indicates that a method produces a bean to be managed by the Spring container. This is one of the most used and important spring annotation. @Bean annotation also can be used with parameters like name, initMethod and destroyMethod.

    • name – allows you give name for bean
    • initMethod – allows you to choose method which will be invoked on context register
    • destroyMethod – allows you to choose method which will be invoked on context shutdown

    For example:

    @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("Load operating system");
    }
    public void turnOff(){
        System.out.println("Close all programs");
    }
}

  3. @PreDestroy and @PostConstruct are alternative way for bean initMethod and destroyMethod. It can be used when the bean class is defined by us. For example;

     public class Computer {

    @PostConstruct
    public void turnOn(){
        System.out.println("Load operating system");
    }

    @PreDestroy
    public void turnOff(){
        System.out.println("Close all programs");
    }
}

  4. @ComponentScan: Configures component scanning directives for use with @Configuration classes. Here we can specify the base packages to scan for spring components.

  5. @Component: Indicates that an annotated class is a “component”. Such classes are considered as candidates for auto-detection when using annotation-based configuration and classpath scanning.

  6. @PropertySource: provides a simple declarative mechanism for adding a property source to Spring’s Environment. There is a similar annotation for adding an array of property source files i.e @PropertySources.

  7. @Service: Indicates that an annotated class is a “Service”. This annotation serves as a specialization of @Component, allowing for implementation classes to be autodetected through classpath scanning.

  8. @Repository: Indicates that an annotated class is a “Repository”. This annotation serves as a specialization of DAO classes.

  9. @Autowired: @Qualifier annotation is used in conjunction with Autowired to avoid confusion when we have two of more bean configured for same type.

Annotimet e pranverës MVC

Disa nga shënimet e rëndësishme Spring MVC janë:

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

Mund të mësoni më shumë rreth tyre në Pranvera MVC Tutorial.

Shënime për menaxhimin e transaksioneve pranverore

@Transactional është shënimi deklarativ pranveror i menaxhimit të transaksioneve, lexoni më shumë në Spring MVC Hibernate.

Shënime për sigurinë e pranverës

@EnableWebSecurity përdoret me Shembullin e Sigurisë Spring.

Shënime për çizmet e pranverës

  1. @SpringBootApplication
  2. @EnableAutoConfiguration

Lexoni më shumë në Shembull i çizmeve të pranverës.

Shembull i shënimeve të pranverës

Varësitë e Kornizës së Pranverës

Unë kam krijuar projektin maven dhe kam shtuar varësitë Spring Core Framework.

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

Kjo do të tërheqë të gjitha kavanozët bazë të pranverës për projektin tonë.

Klasat e komponentëve

Hapi tjetër është krijimi i klasave të komponentëve. Këtu po imitoj shumë komponentë të bazës së të dhënave, një për MySQL dhe një tjetër për Oracle.

package com.journaldev.drivers;

public interface DataBaseDriver {
    public String getInfo();
}

DataBaseDriver është ndërfaqja bazë që do të implementojmë.

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 +
                " ]";
    }
}

Vini re përdorimin e shënimit @Component për të treguar kornizën e pranverës për ta trajtuar këtë klasë si një komponent. Ne po përdorim gjithashtu shënimet @PropertySource dhe @Value, Spring do t'i përdorë këto në kohën e ekzekutimit për të injektuar dhe vendosur këto vlera të ndryshueshme nga skedari i specifikuar i vetive. Më poshtë janë vetitë e deklaruara në skedarin 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 është një fasule e thjeshtë, ne do të përdorim klasën e shërbimit për të injektuar vetitë në këtë fasule.

Klasa e shërbimit pranveror

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

Këtu po përdorim shënimin @Service për të treguar kornizën Spring për ta trajtuar këtë si një klasë Shërbimi. Më pas, ne po përdorim shënimet @Autowired dhe @Qualifier(oracleDriver) për t'i treguar kornizës së pranverës që të injektojë bean të quajtur oracleDriver te vetia e klasës dataBaseDriver. Vini re se ne nuk e kemi krijuar ende këtë fasule pranverore.

Fasule pranverore

Hapi i fundit është krijimi i fasuleve dhe klasave tona të konfigurimit për të ngjitur gjithçka së bashku.

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

Vini re përkufizimin e bean për oracleDriver. Në këtë metodë, ne po lexojmë vetitë nga skedari oracledatabase.properties që po vendoset në variablin environment nga kuadri Spring. Këtu janë vetitë e përcaktuara në skedarin oracledatabase.properties.

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

Projekti ynë shembull i shënimeve pranverore është gati për testim. Si përmbledhje, ne kryem hapat e mëposhtëm:

  1. Krijoi projektin maven dhe shtoi varësitë e nevojshme të pranverës.
  2. Krijoi klasa komponenti dhe injekto vetitë nga një skedar burimi në variablin e tij.
  3. Nëse kemi një komponent të palës së tretë, mund të përdorim klasën e shërbimit për të injektuar varësi në të. Ashtu siç bëmë për OracleDriver përmes klasës UserService.
  4. Më në fund, krijuam klasën e konfigurimit për të përcaktuar fasulet e pranverës dhe vendosëm paketën bazë që të skanojë për klasat e komponentëve të pranverës dhe t'i konfigurojë ato.

Shembull Testimi i Shënimeve të Pranverës

Këtu është klasa jonë kryesore për të testuar shembullin e projektit tonë të shënimeve të pranverës.

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

Shkarko Shkarko Projektin Shembull i Shënimeve të Pranverës

Referenca: API Doc