Detaillierte Einführung in die Verwendung von Anmerkungen zum Konfigurieren von Federn

1. Verwenden Sie Anmerkungen, um Spring zu konfigurieren

1. Schritte

1.1 Leitfadenpaket 4+2+spring-aop

4 steht für:

🎜>

2 steht für:

Protokollpaket: com.springsource.org.apache.commons.logging-1.1.1.jar

Optional: com.springsource org .apache.log4j-1.2.15.jar (die alte Version muss importiert werden, und der Import kann garantieren, dass sie ausgeführt wird)

　 1.2 Führen Sie einen neuen Namespace (Einschränkung) in die Hauptkonfigurationsdatei ein

1.3 Aktivieren Sie die Verwendung von Annotationen anstelle von Konfigurationsdateien

1.4 Verwenden Sie Annotationen in Klassen, um die Konfiguration abzuschließen

2. Registrieren Sie das Objekt im Container

//<bean name="user" class="cn.itcast.bean.User"  />//@Component("user")//    @Service("user") // service层//    @Controller("user") // web层@Repository("user")// dao层

3. Ändern Sie den Umfang des Objekts

//指定对象的作用范围@Scope(scopeName="singleton")

4. Werttypinjektion

Die Feldzuweisung durch Reflexion zerstört die Kapselung:

    @Value("tom")    private String name;

Zuweisung über die Set-Methode wird empfohlen.:

    @Value("tom")    public void setName(String name) {this.name = name;
    }

5. Referenztyp-Injektion

    //@Autowired //自动装配//问题:如果匹配多个类型一致的对象.将无法选择具体注入哪一个对象.//@Qualifier("car2")//使用@Qualifier注解告诉spring容器自动装配哪个名称的对象private Car car;

　

Empfohlene Methode:

    @Resource(name="car")//手动注入,指定注入哪个名称的对象private Car car;

　 6. Initialisierung |. Zerstörungsmethode

    @PostConstruct //在对象被创建后调用.init-methodpublic void init(){
        System.out.println("我是初始化方法!");
    }
    @PreDestroy //在销毁之前调用.destory-methodpublic void destory(){
        System.out.println("我是销毁方法!");
    }

2. STS-Plugin

1. Installieren Sie das Plug-in manuell (geringe Erfolgsquote)

Schritt 1:

Schritt 2:

Schritt 3:

2. Installieren Sie das Plug-in direkt mit Spring Eclipse

　　

3. Spring- und Junit-Integrationstest

1 . Leitfadenpaket 4+2+aop+test

　2. Konfigurationsanmerkungen

//帮我们创建容器@RunWith(SpringJUnit4ClassRunner.class)//指定创建容器时使用哪个配置文件@ContextConfiguration("classpath:applicationContext.xml")public class Demo {//将名为user的对象注入到u变量中@Resource(name="user")private User u;

　3. Test

    @Testpublic void fun1(){
        
        System.out.println(u);
        
    }

4. Frühlings-Aop

1. Einführung in Aop-Ideen

2. Spring Das Aop-Konzept

3. Das Prinzip der Spring-Implementierung von Aop

3.1 Dynamischer Proxy (Priorität)

Das Proxy-Objekt muss die Schnittstelle implementieren, kann Proxy-Objekte generieren. Wenn keine Schnittstelle vorhanden ist, kann die dynamische Proxy-Technologie nicht verwendet werden

　 3.2 cglib-Proxy (keine Schnittstelle)

　 Dritter -Party-Proxy-Technologie, cglib-Proxy. Proxy Das Prinzip besteht darin, das Zielobjekt zu erben und zu vertreten. Wenn das Zielobjekt endgültig geändert wird, kann die Klasse nicht durch cglib vertreten werden >　4.aop Substantivlernen

　

5. AOP-Demonstration im Frühjahr

1. Schritte (XML-Konfiguration)

1.1 Leitfadenpaket 4+2

Frühlings-Aop-Paket:

　spring-aspects-4.2.4.RELEASE.jar

　spring-aop-4.2.4.RELEASE .jar

Spring erfordert ein AOP-Paket eines Drittanbieters:

　com.springsource.org.aopalliance-1.0.0.jar

　com.springsource.org.aspectj. weaver-1.6.8.RELEASE.jar

　 1.2 Zielobjekt vorbereiten

　 1.3 Benachrichtigung vorbereiten

public class UserServiceImpl implements UserService {
    @Overridepublic void save() {
        System.out.println("保存用户!");//int i = 1/0;    }
    @Overridepublic void delete() {
        System.out.println("删除用户!");
    }
    @Overridepublic void update() {
        System.out.println("更新用户!");
    }
    @Overridepublic void find() {
        System.out.println("查找用户!");
    }
}

　 1.4 Konfigurieren Sie das Weben und weben Sie die Benachrichtigung in das Zielobjekt

//通知类public class MyAdvice {    //前置通知    
//        |-目标方法运行之前调用//后置通知(如果出现异常不会调用)//        |-在目标方法运行之后调用//环绕通知//        |-在目标方法之前和之后都调用//异常拦截通知//        |-如果出现异常,就会调用//后置通知(无论是否出现 异常都会调用)//        |-在目标方法运行之后调用//----------------------------------------------------------------//前置通知public void before(){
        System.out.println("这是前置通知!!");
    }//后置通知public void afterReturning(){
        System.out.println("这是后置通知(如果出现异常不会调用)!!");
    }//环绕通知public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("这是环绕通知之前的部分!!");
        Object proceed = pjp.proceed();//调用目标方法System.out.println("这是环绕通知之后的部分!!");return proceed;
    }//异常通知public void afterException(){
        System.out.println("出事啦!出现异常了!!");
    }//后置通知public void after(){
        System.out.println("这是后置通知(出现异常也会调用)!!");
    }
}

　2. Schritte (Annotationskonfiguration)

<?xml version="1.0" encoding="UTF-8"?><beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/context  http://www.springframework.org/schema/aop  "><!-- 准备工作: 导入aop(约束)命名空间 --><!-- 1.配置目标对象 --><bean name="userService" class="cn.itcast.service.UserServiceImpl" ></bean><!-- 2.配置通知对象 --><bean name="myAdvice" class="cn.itcast.d_springaop.MyAdvice" ></bean><!-- 3.配置将通知织入目标对象 --><aop:config><!-- 配置切入点 
            public void cn.itcast.service.UserServiceImpl.save() 
            void cn.itcast.service.UserServiceImpl.save()
            * cn.itcast.service.UserServiceImpl.save()
            * cn.itcast.service.UserServiceImpl.*()
            
            * cn.itcast.service.*ServiceImpl.*(..)
            * cn.itcast.service..*ServiceImpl.*(..)--><aop:pointcut expression="execution(* cn.itcast.service.*ServiceImpl.*(..))" id="pc"/><aop:aspect ref="myAdvice" ><!-- 指定名为before方法作为前置通知 --><aop:before method="before" pointcut-ref="pc" /><!-- 后置 --><aop:after-returning method="afterReturning" pointcut-ref="pc" /><!-- 环绕通知 --><aop:around method="around" pointcut-ref="pc" /><!-- 异常拦截通知 --><aop:after-throwing method="afterException" pointcut-ref="pc"/><!-- 后置 --><aop:after method="after" pointcut-ref="pc"/></aop:aspect></aop:config></beans>

Die vorherigen Schritte 1, 2 und 3 sind die gleichen wie die XML-Konfiguration

2.4 Die Konfiguration ist in die Benachrichtigungswebung eingebunden. In das Zielobjekt

ApplicationContext.xml:

Benachrichtigungsklasse:

<?xml version="1.0" encoding="UTF-8"?><beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/context  http://www.springframework.org/schema/aop  "><!-- 准备工作: 导入aop(约束)命名空间 --><!-- 1.配置目标对象 --><bean name="userService" class="cn.itcast.service.UserServiceImpl" ></bean><!-- 2.配置通知对象 --><bean name="myAdvice" class="cn.itcast.e_annotationaop.MyAdvice" ></bean><!-- 3.开启使用注解完成织入 --><aop:aspectj-autoproxy></aop:aspectj-autoproxy></beans>

//通知类@Aspect//表示该类是一个通知类public class MyAdvice {
    @Pointcut("execution(* cn.itcast.service.*ServiceImpl.*(..))")public void pc(){}//前置通知//指定该方法是前置通知,并制定切入点@Before("MyAdvice.pc()")public void before(){
        System.out.println("这是前置通知!!");
    }//后置通知@AfterReturning("execution(* cn.itcast.service.*ServiceImpl.*(..))")public void afterReturning(){
        System.out.println("这是后置通知(如果出现异常不会调用)!!");
    }//环绕通知@Around("execution(* cn.itcast.service.*ServiceImpl.*(..))")public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("这是环绕通知之前的部分!!");
        Object proceed = pjp.proceed();//调用目标方法System.out.println("这是环绕通知之后的部分!!");return proceed;
    }//异常通知@AfterThrowing("execution(* cn.itcast.service.*ServiceImpl.*(..))")public void afterException(){
        System.out.println("出事啦!出现异常了!!");
    }//后置通知@After("execution(* cn.itcast.service.*ServiceImpl.*(..))")public void after(){
        System.out.println("这是后置通知(出现异常也会调用)!!");
    }
}

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in die Verwendung von Anmerkungen zum Konfigurieren von Federn. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!