JavaWeb Spring注解Annotation深入学习
一、注解
注解annotation，是一种类似注释的机制，在代码中添加注解可以在之后某时间使用这些信息。跟注释不同的是，注释是给我们看的，java虚拟机不会编译，注解也是不编译的，但是我们可以通过反射机制去读取注解中的信息。注解使用关键字@interface，继承java.lang.annotition.annotition
1、javase中的注解
先举个例子来回顾一下在javase中注解是什么东东，关键是两点，注解的定义与如何通过反射得到注解上面的信息。
1.先定义两个注解一个是在类上有注解classinfo，一个是在方法上有注解为methodinfo.
classinfo
package com.itheima10.annotation;
import java.lang.annotation.documented;
import java.lang.annotation.elementtype;
import java.lang.annotation.retention;
import java.lang.annotation.retentionpolicy;
import java.lang.annotation.target;
@target(elementtype.type) //该注解可以用于类上
@retention(retentionpolicy.runtime) //在java,class文件以及运行时注解都起作用
@documented //能生成在帮助文档中
public @interface classinfo {
/**
* 该注解有两个string类型的属性
* @return
*/
string name() default "";
string value() default "";
}
methodinfo
package com.itheima10.annotation;
import java.lang.annotation.documented;
import java.lang.annotation.elementtype;
import java.lang.annotation.retention;
import java.lang.annotation.retentionpolicy;
import java.lang.annotation.target;
@target(elementtype.method) //该注解可以用于方法上
@retention(retentionpolicy.runtime) //在java,class文件以及运行时注解都起作用
@documented //能生成在帮助文档中
public @interface methodinfo {
/**
* 该注解有两个string类型的属性
*/
string name() default "";
string value() default "";
}
2.写一个类annotationuse来使用上面定义的注解
package com.itheima10.annotation;
@classinfo(name="小平果118",value="牛")
public class annotationuse {
@methodinfo(name="java",value="spring框架很重要")
public void java(){
}
}
3.编写测试类annotationtest，解析上述两个注解上面的属性
package com.itheima10.annotation;
import java.lang.reflect.method;
import org.junit.test;
public class annotationtest {
public static void test(){
/**
* 如果解析类的注解，先得到class
* 如果解析方法的注解，先得到method
*/
class class1 = itheima10.class;
//判断类上面是否有classinfo注解
if(class1.isannotationpresent(classinfo.class)){
//得到类上面的注解
classinfo classinfo = (classinfo)class1.getannotation(classinfo.class);
system.out.println(classinfo.value());
system.out.println(classinfo.name());
}
method[] methods = class1.getmethods();
for (method method : methods) {
//正在遍历的方法上面是否存在methodinfo注解
if(method.isannotationpresent(methodinfo.class)){
methodinfo methodinfo = method.getannotation(methodinfo.class);
system.out.println(methodinfo.name());
system.out.println(methodinfo.value());
}
}
}
@test
public void test(){
annotationtest.test();
}
}
2、spring中的注解
spring框架为我们提供了注解功能。
使用注解编程，主要是为了替代xml文件，使开发更加快速。但是，xml文件的使用就是解决修改程序修改源代码，现在又不去使用xml文件，那么不就违背了开闭原则了么，得确是。不过么，注解也有注解的好，使用注解就不用配置那么多的xml文件啦，最重要的是开发效率高。。
在没有使用注解时，spring框架的配置文件applicationcontext.xml文件中需要配置很多的<bean>标签，用来声明类对象。使用注解，则不必在配置文件中添加标签拉，对应的是在对应类的“注释”位置添加说明。具体介绍如下：
•1.@resource 对象间关系的组合，默认采用的是按名称方式进行装配，如果根据名称查找不到关联的对象，那么会再采用按类型继续查找。如果没有指定name属性，
• 当注解标注在字段上，即默认取字段的名称作为bean名称寻找依赖对象
• 当注解标注在属性的setter方法上，即默认取属性名作为bean名称寻找依赖对象。
• 注意：如果没有指定name属性，并且按照默认的名称找不到依赖对象时， @resource注解会回退到按类型装配。但一旦指定了name属性，就只能按名称装配了。
•2. @autowired
@autowired 默认按类型装配，@resource默认按名称装配，当找不到与名称匹配的bean才会按类型装配。 解是按类型装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它required属性为false。
•3、 @qualifier
如果我们想使用按名称装配，可以结合@qualifier注解一起使用。
1、使用注解，需要在配置文件中增加命名空间和约束文件步骤：
引入context命名空间
<beans xmlns=""
xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
xmlns:context=""
...
">
2、 在配置文件中加入context:annotation-config标签
<context:annotation-config></context:annotation-config>
实例演示：
编写一个person类，其中有一个student属性，以及一个say()方法，代码如下
package com.itheima10.spring.di.annotation;
import javax.annotation.resource;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.beans.factory.annotation.qualifier;
/**
* @autowired//按照类型进行匹配
*
* @autowired//按照类型进行匹配
@qualifier("student")
*
*/
public class person {
@resource(name="student")
private student student;
public void say(){
this.student.say();
}
}
student类代码如下
package com.itheima10.spring.di.annotation;
public class student {
public void say(){
system.out.println("student");
}
}
配置applicationcontext.xml文件
<?xml version="1.0" encoding="utf-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" 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-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"> <!-- 把person和student放入到spring容器中 --> <bean id="person" class="com.itheima10.spring.di.annotation.person"></bean> <bean id="student" class="com.itheima10.spring.di.annotation.student"></bean> <!-- 引入context命名空间 xmlns:context="http://www.springframework.org/schema/context" http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd" --> <!-- 启动了以来注入的注解解析器 --> <context:annotation-config></context:annotation-config> </beans>
编写测试类annotationtest
package com.itheima10.spring.di.annotation;
import org.junit.test;
import org.springframework.context.applicationcontext;
import org.springframework.context.support.classpathxmlapplicationcontext;
/**
* 原理:
* 1、启动spring容器
* 2、把person和student两个bean实例化
* 3、当spring容器解析到
* <context:annotation-config></context:annotation-config>
* 就会启动依赖注入的注解解析器
* 4、spring容器会在纳入spring管理的bean的范围内查找,看这些类的哪些属性上加有@resource注解
* 5、如果某一个属性上加有@resource注解
* 会查看该注解的name属性的值是否为""
* 如果为"",则会把该注解所在的属性的名称和spring容器中的id的值作匹配，如果匹配成功，则赋值
* 如果匹配不成功，则按照类型进行匹配,匹配成功则赋值
* 如果再匹配不成功,则报错
* 如果不为"",则把该注解的name属性的值和spring容器中id的值作匹配，如果匹配成功，则赋值
* 如果匹配不成功,则直接报错
*
说明:
注解只能作用于引用类型
xml与注解的对比
xml的效率比较高，书写比较麻烦
注解的书写比较简单，效率比较低
*
*/
public class annotationtest {
@test
public void testannotation(){
applicationcontext context =
new classpathxmlapplicationcontext("applicationcontext.xml");
person person = (person)context.getbean("person");
person.say();
}
}
如果使用注解，就不需要在配置文件中装载person和student了，这样就可以简化配置文件的编写。
3、 扫描
前面的例子我们都是使用xml的bean定义来配置组件。在一个稍大的项目中，通常会有上百个组件，如果这些组件采用xml的bean定义来配置，显然会增加配置文件的体积，查找及维护起来也不太方便。spring2.5为我们引入了组件自动扫描机制，它可以在类路径底下寻找标注了@component、@service、@controller、@repository注解的类，并把这些类纳入进spring容器中管理。它的作用和在xml文件中使用bean节点配置组件是一样的。要使用自动扫描机制，我们需要打开以下配置信息:
1、引入context命名空间
在xml配置文件中添加context:component-scan标签
其中base-package为需要扫描的包(含子包)。
实例：
将上述实例用扫描的方式书写如下
@component
public class person {
@resource(name="student")
private student student;
public void say(){
this.student.say();
}
}
@component
public class student {
public void say(){
system.out.println("student");
}
}
applicationcontext.xml只需配置一句话
<!-- component 组件 把一个类放入到spring容器中，该类就称为组件 在base-package指定的包及子包下扫描 --> <context:component-scan base-package="com.itheima10.spring.scan"></context:component-scan>
编写测试类annotationtest
/**
* 原理
* 1、启动spring容器
* 2、spring容器解析
* <context:component-scan base-package="com.itheima10.spring.scan">
</context:component-scan>
3、在base-package指定的包及子包中扫描,看哪些类上面是否含有@component注解
4、如果有该注解
@component
public class person {
}
==等价于
<bean id="person" class="..person">
@component("aa")
public class person {
}
==等价于
<bean id="aa" class="..person">
5、按照@resource的解析步骤执行
说明：
整个过程扫描两次，效率越来越低，书写越来越简单
*
*
*/
public class annotationtest {
@test
public void testannotation(){
applicationcontext context =
new classpathxmlapplicationcontext("applicationcontext.xml");
person person = (person)context.getbean("person");
person.say();
}
}
实例再现
我们将item51中最后的文档管理系统用注解的方式改一下，document接口不变，有read和write方法，实现类分别如下exceldocument ，pdfdocument ，worddocument 。
@component("exceldocument")
public class exceldocument implements document{
public void read() {
system.out.println("excel read");
}
public void write() {
system.out.println("excel write");
}
}
@component("pdfdocument")
public class pdfdocument implements document{
public void read() {
system.out.println("pdf read");
}
public void write() {
system.out.println("pdf write");
}
}
@component("worddocument")
public class worddocument implements document{
public void read() {
system.out.println("word read");
}
public void write() {
system.out.println("word write");
}
}
documentmanager
@component("documentmanager")
public class documentmanager {
@resource(name="exceldocument")
private document document;
public void read(){
this.document.read();
}
public void write(){
this.document.write();
}
}
配置文件
<context:component-scan base-package="com.itheima10.spring.iocdi.document">
</context:component-scan>
编写测试类documenttest
public class documenttest {
@test
public void testdocument(){
applicationcontext context = new classpathxmlapplicationcontext("applicationcontext.xml");
documentmanager documentmanager = (documentmanager)context.getbean("documentmanager");
documentmanager.read();
documentmanager.write();
}
}
2、其他注解功能介绍
@service用于标注业务层组件、服务层注解
@controller用于标注控制层组件（如struts中的action）、控制层注解
@repository用于标注数据访问组件，即dao组件。持久层注解
而@component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。
实例重现–mvc案例
我们再次回顾item51中的mvc案例，分别将persondaoimpl ，personaction ，personserviceimpl 的dao,service,action层加上注解有
@repository("persondao")
public class persondaoimpl implements persondao {
@override
public void saveperson() {
system.out.println(" save person");
}
}
@service("personservice")
public class personserviceimpl implements personservice{
@resource(name="persondao")
private persondao persondao;
public void setpersondao(persondao persondao) {
this.persondao = persondao;
}
@override
public void saveperson() {
this.persondao.saveperson();
}
}
@controller("personaction")
public class personaction {
@resource(name="personservice")
private personservice personservice;
public void setpersonservice(personservice personservice) {
this.personservice = personservice;
}
public void saveperson(){
this.personservice.saveperson();
}
}
编写测试mvctest
public class mvctest {
@test
public void testmvc(){
applicationcontext context =
new classpathxmlapplicationcontext("applicationcontext.xml");
personaction personaction = (personaction)context.getbean("personaction");
personaction.saveperson();
}
}
4. spring中的继承
spring支持继承，可以分为类继承和属性继承
1. 类继承
spring属性：
（1）abstract： 如果设置为true，表示定义的bean是抽象的，告诉spring不要实例化这个bean；
问题：必须是抽象类么？可以不是抽象类么？
（2）parent: 指明bean的id，对bean的作用，相当于extends对于java类的作用；
场景：有三个bean：
<bean id = "bean1" class = "……testbean"> <property name="sex" value="male"/> </bean> <bean id = "bean2" class = "……testbean"> <property name="sex" value="male"/> </bean> <bean id = "bean3" class = "……testbean"> <property name="sex" value="female"/> </bean>
修改：定义spring 父bean
<bean id ="basebean" class ="……testbean"> <property name="sex" value="male"/> </bean>
定义子bean
<bean id ="bean1" parent = "basebean"/> 继承父bean的属性 <bean id ="bean2" parent = "basebean"/> <bean id ="bean3" parent = "basebean"> 覆盖父bean的属性 <property name="sex" value="female"/> </bean>
子bean可以继承父bean的属性，也可以覆盖父bean的属性
2. 属性继承
几个不同bean之间存在相同的属性，可以抽离出来
场景：
<bean id = "bean1" class = "……atestbean"> <property name="sex" value="male"/> <property name="task" ref="task"/> </bean> <bean id = "bean2" class = "……btestbean"> <property name="sex" value="male"/> </bean>
修改：(1) 抽取公共属性
<bean id = "basesex" abstract="true"> <property name="sex" value="male"/> </bean>
(2)bean修改
<bean id = "bean1" class = "……atestbean" parent="basesex"> <property name="task" ref="task"/> </bean> <bean id = "bean2" class = "……btestbean" parent="basesex"/>
这里bean同时有parent和class属性，其中parent指向的basesex，就是为了让不同bean之间共享相同的属性值；在transactionproxyfactorybean声明业务时，bean属性继承能够明显的减少冗余的xml配置。
基于注解的继承无需要parent属性。
最后上一张小小的总结图吧
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。
上一篇： Java语法基础之选择结构的if语句、switch语句详解
下一篇： php实现遍历文件夹的方法汇总