spring注解开发

发表于 | 分类于 ，
字数统计: 1.4k | 阅读时长 ≈ 6

DI注解

Autowired 注解和 Resource 注解:
共同点:
1.可以自动的把属性需要的对象找出来,并自动注入
2.可以贴在字段或者 setter 方法上面,一般贴在字段上(不再需要 setter 方法)
3.可以注入一些 Spring 内置的重要对象,甚至是 Servlet 的 API 比如 BeanFactory、 ApplicationContext、ServletContext 等
不同点:
1.Autowired 和 Resource 注解都必须要能找到对应的对象,否则报错.只是 Autowired 注解可以通过 required=false 来避免这个问题:@Autowired(required=false)
2.Autowired:先按照类型找,找不到再按名字去找,可以配合@Qualifier 注解一起使用.
Resource:先按照名字找,找不到再按类型找.@Resource(name=””)

开发中建议必须配置

1
<context:annotation-config />

使用 Autowired 注解

1
2
3
4
5
public class SomeBean {
    @Autowired
    @Qualifier("otherBean")
    private OtherBean other;
}

使用 Resource 注解

1
2
3
4
public class SomeBean {
    @Resource(name=”otherBean”)
    private OtherBean other;
}

Value 注解
Autowired 和 Resource 注解用于注入对象,Value 注解用于注入常量数据(简单类型数据)
server.properties 文件

1
2
server.port=8888
server.path=/

Java 代码

1
2
@Value("${server.port}")
private int port;

引入配置文件

1
<context:property-placeholder location="classpath:db.properties,classpath:server.properties"/>

或者

1
2
3
4
<context:property-placeholder
         location="classpath:db.properties" ignore-unresolvable="true"/>
<context:property-placeholder
         location="classpath:server.properties" ignore-unresolvable="true"/>

IoC 注解

不同组件的注解

bean 组件版型:组件的功能是相同的,只是用于标注不同类型的组件

@Repository 用于标注数据访问组件,即 DAO 组件.
@Service 用于标注业务层组件,即 Service 组件.
@Controller 只用于标注控制层组件(SpringMVC 的 Controller).
@Component 泛指组件,当组件不好归类的时候,我们可以使用这个注解进行标注

此时需要配置 IoC 注解的解析器

1
<context:component-scan base-package=""/>表示去哪些包中及其子包中去扫描组件注解

Java 代码(同时实现 IoC 和 DI 配置)

1
2
3
4
5
6
7
8
9
@Component("otherBean")
    public class OtherBean {
}

@Component
public class SomeBean {
    @Autowired
    private OtherBean other;
}

xml配置

1
2
3
4
<!-- DI 注解解释器 -->
<context:annotation-config/>
<!-- IoC 注解解释器 -->
<context:component-scan base-package="me.cscar.ssm"/>

作用域注解

XML配置

1
<bean id="otherBean" class="...OtherBean" scope="singleton"/>

使用:使用 Scope 注解，设置 Bean 的作用域

1
2
3
4
5
@Component
@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
public class OtherBean {

}

初始化和销毁注解

使用 XML 方式的配置 bean 的初始化和销毁方法

1
2
3
4
<bean id="someBean" class="...SomeBean"
    init-method="open"
    destroy-method="close"
/>

@PostConstruct 用于贴在初始化方法上
@PreDestroy 用于贴在销毁方法上

1
2
3
4
5
6
7
8
@PostConstruct
public void open() {
    System.out.println("初始化方法"); 
}
@PreDestroy
public void close() {
    System.out.println("销毁方法"); 
}

AOP 注解

使用 XML 方式的配置 AOP(基于 JDK 动态代理)
xml配置:
一定要先开启 AOP 注解的解释器

1
2
3
4
5
<!-- IoC 注解解释器 -->
<context:component-scan base-package="cn.wolfcode.ssm" /> <!-- DI 注解解释器 -->
<context:annotation-config />
<!-- AOP 注解解释器 -->
<aop:aspectj-autoproxy />

Aspect : 声明一个切面,贴在增强类之上
Pointcut : 贴到一个方法上,用于声明 pointcut 语法,被贴方法的名字作为 pointcut 语法 id
Before : 贴到需要做前置增强的方法上
After : 贴到需要做后置增强的方法上
AfterThroing : 贴到需要做异常增强的方法上
AfterReturing : 贴到需要做最终增强的方法上
Around : 贴到需要做环绕增强的方法上

Java 代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
@Component
@Aspect
public class TransctionManager {

    @Pointcut("execution(* cn.wolfcode.ssm.service.*Service.*(..))")
    public void txPoint() {
    }

    @org.aspectj.lang.annotation.Before("txPoint()")
    public void begin(JoinPoint jp) {
        System.out.println("开启事务"); 
    }

    @org.aspectj.lang.annotation.AfterReturning("txPoint()")
    public void commit() {
        System.out.println("提交事务"); 
    }

    @org.aspectj.lang.annotation.After("txPoint()")
    public void close() {
        System.out.println("释放资源"); 
    }

    @org.aspectj.lang.annotation.AfterThrowing(value = "txPoint()", throwing = "ex")
    public void rollback(Throwable ex) {
        System.out.println("回滚事务" + ex); 
    }

    @org.aspectj.lang.annotation.Around(value = "txPoint()")
    public Object around(ProceedingJoinPoint pjp) { Object ret = null; System.out.println("开启事务");
    try {
        //执行目标方法
        ret = pjp.proceed(); System.out.println("提交事务");
    } 
    catch (Throwable ex) { System.out.println("回滚事务");
    } 
    finally {
        System.out.println("释放资源"); 
    }
    return ret; 
    }
}

默认使用的 JDK 动态代理方式,可以设置使用 CGLIB 方式
XML 配置:

1
<aop:aspectj-autoproxy proxy-target-class="true"/>

修改切入点表达式

1
2
3
@Pointcut("execution(* me.cscar.ssm.service..*(..))")
public void txPoint() {
}

Tx注解

1
2
3
4
5
6
7
<tx:advice id="crudAdvice" transaction-manager="txManager">
    <tx:attributes>
        <!-- service 中查询方法 -->
        <tx:method name="get*" read-only="true"/> <tx:method name="list*" read-only="true"/>    <tx:method name="query*" read-only="true"/> <!-- service 中其他方法 -->
        <tx:method name="*"/>
    </tx:attributes>
</tx:advice>

具体使用
贴在类上:该类中所有的方法,都使用 Transactional 注解的属性配置
贴在方法上:只针对被贴的这一个方法,一般用于做单独配置.
一般的,我们可以在业务类上直接贴该注解,并在查询方法上设置 readOnly 属性为 true.
注意:一定要记得开启 Tx 注解的解释器

使用JDK

1
2
3
4
5
6
7
8
9
10
11
12
13
<!-- IoC 注解解析器 -->
<context:annotation-config />
<!-- DI 注解解析器 -->
<context:component-scan base-package="cn.wolfcode.ssm" /> 
<!-- TX 注解解析器 -->
<tx:annotation-driven transaction-manager="txManager" />

<!-- 配置 JDBC 事务管理器 --> 
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

...........

使用 CGLIB

1
<tx:annotation-driven transaction-manager="txManager" proxy-target-class="true"/>

java代码

1
2
3
4
5
6
7
8
9
10
11
@Service
@Transactional
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private IAccountDAO dao;
    public void trans(Long outId, Long inId, int money) {
    dao.transOut(outId, money);
    int a = 1 / 0;
    dao.transIn(inId, money);
    } 
}