Sping中自定义默认注解名生成器

在类中贴上@Repository等标签,相当于在Spring容器里定义了一个Bean类,这个Bean的名称如果不指定名称,将默认使用当前类名(不含包名)的首字母小写作为Bean的名字.

需求:

要确保这个Bean名称要唯一,显然这样定义的Bean名称太过简单,比较容易造成一样情况,如果能使用全类名作为Bean可防止这样的情况,因为不存在全类名一样的类.例如:org.kirinsoft.frame.AClass

技术实现:

指定定义一个Bean名字生成器,实现Spring提供的BeanNameGenerator,在generateBeanName方法中设计出自己需要的Bean名称.

另外在Spring配置文件中的自动注解配置要指定名字生成器类,如:

<!-- 自动注解配置 -->
<context:annotation-config />
<context:component-scan base-package="com.kirinsoft.frame"
    name-generator="com.kirinsoft.frame.pub.UniqueBeanNameGenerator" />

具体实现方法:

/**
 * 唯一Bean名称生成器.以类全名作为Bean名称.
 */
public class UniqueBeanNameGenerator implements BeanNameGenerator{
 
    @Override
    public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
        return definition.getBeanClassName();
    }
}

Spring中事务的作用范围

下面一种情景:

在做项目中通常会进行分层架构.假设可分为Service、Biz、Dao3层.关系如下:

一个Service类调用多个Biz类,一个Biz调用多个Dao类完成业务逻辑.

基于这种情况,通常我们把事务控制到Service层.

很当然的引入Spring中配置:（其他配置略）

<property name="beanNames">
            <list>
                <value>*ServiceImpl</value>
            </list>
        </property>

那么,引入一个问题：如果同时对Service层和Biz层加入Spring的事务配置中,是哪一层起作用呢、？

换句话说，假设一个Service有两个Biz类，那么第一个Biz类操作成功,而第二个操作失败,此时第一个Biz是否有回滚呢。?

对应的Spring配置：

<property name="beanNames">
    <list>
        <value>*ServiceImpl</value>
        <value>*BizImpl</value>
    </list>
</property>

通过实验证明可得到结论：哪个包含的范围大，哪个事务起作用。

上面的假设，Service的事务起作用,第一个Biz会被回滚掉。

Spring事务属性说明

Spring事务属性配置属性说明如下:

PROPAGATION_REQUIRED

【支持当前事务，如果当前没有事务，就新建一个事务。（常用）】

PROPAGATION_SUPPORTS

【支持当前事务，如果当前没有事务，就以非事务方式执行】

PROPAGATION_MANDATORY

【支持当前事务，如果当前没有事务，就抛出异常】

PROPAGATION_REQUIRES_NEW

【新建事务，如果当前存在事务，把当前事务挂起】

PROPAGATION_NOT_SUPPORTED

【以非事务方式执行操作，如果当前存在事务，就把当前事务挂起】

PROPAGATION_NEVER

【以非事务方式执行，如果当前存在事务，则抛出异常】

PROPAGATION_NESTED

【如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作】

-Exception表示有Exception抛出时,事务回滚。-代表回滚+就代表提交

readonly 就是read only, 设置操作权限为只读,一般用于查询的方法,优化作用

Spring AOP 之 RegexpMethodPointcutAdvisor

昨天，做了有关日志的AOP，对相关的AOP知识总结如下：

1.引入AOP(Aspect Oroented Programming) 面向切面编程，是消除代码重复的一种方法。

2.Spring AOP 中提供了两种PointcutAdvisor，分别是：

①org.springframework.aop.support.RegexpMethodPointcutAdvisor （需要加上完整类名，可以用Spring提供的匹配方式）

②org.springframework.aop.support.NameMatchMethodPointcutAdvisor（只需要方法名，不用加类名）

今天，主要来说明下RegexpMethodPointcutAdvisor的用法。贴一个例子来说明，一些说明都写在注释中~看贴的代码：

IPrinter（打印接口）
1 2 3 4 5 6 7 8 9	`/*` ` 打印接口` `* @author ChenST` `/` `public` `interface` `IPrinter {` `/* 打印接口 */` `public` `void` `print();` `}`

PrinterImpl（打印实现类）
1 2 3 4 5 6 7 8 9 10 11 12	`/*` ` 打印接口实现类` `* @author ChenST` `*/` `@Repository` `public` `class` `PrinterImpl` `implements` `IPrinter{` `@Override` `public` `void` `print() {` `System.out.println("hello world");` `}` `}`

AfterPrinter（切入对象）
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17	`/*` ` 通知,在执行方法执行后调用该方法` `* @author ChenST` `*/` `//对应的还有MethodBeforeAdvice等` `public` `class` `AfterPrinter` `implements` `AfterReturningAdvice{` `//第一个参数表示切入方法的 [返回对象]` `//第二个参数表示切入方法的 [方法反射对象]` `//第三个参数表示切入方法的 [参数数组(方法的所有参数组成)]` `//第四个参数表示 [调用该方法的对象]` `@Override` `public` `void` `afterReturning(Object returnObject, Method method,` `Object[] argArray, Object callObject)` `throws` `Throwable {` `System.out.println("add log:print Hello world");` `}` `}`

Spring配置文件
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	`<context:annotation-config` `/>` `<context:component-scan` `base-package="com.shine"` `/>` `<bean` `id="printer"` `class="com.shine.PrinterImpl"/>` `<bean` `id="afterPrinter"` `class="com.shine.AfterPrinter"/>` `<!-- 配置一个拦截器 (切入点对象,确定何时何地调用拦截器) -->` `<bean` `id="pointcutAdvisor"` `class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">` `<!-- [通知,特定连接点所采取的动作] -->` `<!-- 加入切面,切面为当执行完print方法后再执行加入的切面 -->` `<property` `name="advice">` `<ref` `local="afterPrinter"/>` `</property>` `<!-- 要拦截的方法,可根据Spring提供匹配方式进行拦截 -->` `<property` `name="pattern">` `<!-- .表示符合任何单一字元` `### +表示符合前一个字元一次或多次` `### 表示符合前一个字元零次或多次` `### \Escape任何Regular expression使用到的符号` `-->` `<!-- .表示前面的前缀(包括包名) 表示print方法-->` `<value>.*print</value>` `</property>` `</bean>` `<!-- ### 代理工程 -->` `<bean` `id="proxyFactory"` `class="org.springframework.aop.framework.ProxyFactoryBean">` `<!-- 指定目标对象,目标对象是PrinterImpl对象 -->` `<property` `name="target">` `<ref` `local="printer"/>` `</property>` `<!-- 该目标中加入拦截器pointcutAdvisor -->` `<property` `name="interceptorNames">` `<list>` `<value>pointcutAdvisor</value>` `</list>` `</property>` `</bean>`

测试类
1 2 3 4 5 6 7 8 9 10 11 12 13	`/*` ` 测试类` `*/` `public` `class` `TestMain {` `public` `static` `void` `main(String[] args) {` `ApplicationContext ctx =` `new` `FileSystemXmlApplicationContext(` `"classpath:applicationContext.xml");` `// ☆注意:这里的Bean对象获取必须从代理工厂中去取,否则无法切入` `IPrinter printer = (IPrinter) ctx.getBean("proxyFactory");` `printer.print();` `}` `}`

运行结果
1 2	`hello world` `add` `log:print` `Hello world`

感觉这么多开源东西中，最需要研究的就是Spring了~~ = =|| 继续study~~

No Hibernate Session bound to thread,and configuration does not allow creation错误解决方案

忽遇如下错误：

org.hibernate.HibernateException: No Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here

百度得解：

因：将对应操作入事务即可

方法：于Spring配置文件的事务拦截器中加入对应的类即可~

出现Unable to find Bean with name XXX 可能原因

今天在公司做项目中，

由Ctrl层 >>> Biz层>>> Dao层。在Ctrl注入Biz层类，在Biz层类注入Dao层类，使用注解的方式进行注入，例如，在Biz层注入Dao层的时候，首先需要将Dao层暴露出来，也就是将这个类标上 @Repository等注解，不然可能会出现Unable to find Bean with name的错误。原理实际上就是定义了一个Bean,没有定义的Bean使用注入自然是找不到这个Bean对象咯~~

换句话说若出现：Unable to find Bean with name 这种错误，不妨看看被注入类是否暴露给其他类咯~~也许是这个问题~

Spring中ApplicationContextAware接口用法

加载Spring配置文件时，如果Spring配置文件中所定义的Bean类，如果该类实现了ApplicationContextAware接口，那么在加载Spring配置文件时，会自动调用ApplicationContextAware接口中的

public void setApplicationContext(ApplicationContext context) throws BeansException

方法，并且自动可获得ApplicationContext 对象。前提必须在Spring配置文件中指定改类。

一个Demo程序如下：

Spring配置文件中配置：

1	`<bean` `id="springContext"` `class="com.shine.spring.SpringContextHelper"></bean>`

/**
 * ApplicationContext的帮助类
 * 自动装载ApplicationContext
 * 
 * @author ChenST
 * @create 2010-6-24
 * 
 */
public class SpringContextHelper implements ApplicationContextAware {
     
    private static ApplicationContext context ;
     
    /*
     * 注入ApplicationContext
     */
    @Override
    public void setApplicationContext(ApplicationContext context)
            throws BeansException {
        //在加载Spring时自动获得context
        SpringContextHelper.context = context;
        System.out.println(SpringContextHelper.context);
    }
     
    public static Object getBean(String beanName){
        return context.getBean(beanName);
    }
}

Spring中抽象类不能注入属性

昨天做项目的时候，因为注入用的很爽，自然而然的在什么类下都用注入，结果出问题，注入的属性都是为null，查了一下，会不会是抽象类的问题呢，百度之,得下面的答案：

抽象类不能生成实例对象，spring无法注入。
因为spring的原理是启动服务器时读取配置文件，取得类名后利用反射机制在spring上下文中生成一个单例的对象，由spring注入属性并维护此对象的状态，抽象类在反射生成对象时就已经失败了，后面的不会进行。

Spring2.5常用注解

公司代码很多Spring注解，下午花了点时间学习了下。贴个小案例来使用这些注解：

学习的注解列表

@Component

@Service

@Repository

@Controller

@Autowired

@Qualifier

@Resource

@PostConstruct

@PreDestroy

1.水果接口

/**
 * 水果接口
 * 
 * @author ChenST
 *
 */
public interface Fruit {
    /**
     * 获取水果的名字
     * @return
     */
    public String getName();
}

2.苹果类

/**
 * 苹果
 * @author ChenST
 *
 */
@Service
public class Apple implements Fruit {
 
    /*
     * (non-Javadoc)
     * @see com.spring.annotation.Fruit#getName()
     */
    public String getName() {
        return "苹果";
    }
}

3.梨类

/**
 * 梨
 * @author ChenST
 *
 */
@Service
public class Pear implements Fruit {
 
    public String getName() {
        return "梨";
    }
}

4.人类

/**
 * 人，拥有水果
 * @author ChenST
 *
 */
/*
 * @Service表示定义个Bean对象默认Bean的名字为
 * 类的第一个字母小写名字,例如Human为human
 * @Service("name")也可以自己指定名字name
 * ----------以下四种注解是等效的,只是意义不同
 * @Component 比较中立的类进行注释
 * @Service   表示服务层
 * @Repository表示持久层
 * @Controller表示控制层
 */
@Service
public class Human {
     
    /** 表示拥有水果 */
    /*@Autowired(required = false)表示不确定
     *Spring容器中拥有某个类的Bean时候,这样Spring
     *找不到这个Bean时也不报错
     *
     *@Autowired注解表示自动注入对象。在配置文件中需要配置
     *<context:annotation-config />
     *<context:component-scan base-package="*"/>
     *
     *@Qualifier("apple")表示当这个fruit有两个实现类时
     *指定其中一个。负责会报错
     *
     *@Resource注释与Autowired差不多,Resource可以通过
     *name和type来指明要注入的类
     */
    //@Autowired
    //@Qualifier("apple")
    //@Resource(name="apple")
    @Resource(type=Apple.class)
    private Fruit fruit;
     
    public void setFruit(Fruit fruit) {
        this.fruit = fruit;
    }
 
    /**
     * 吃水果
     */
    public void eat(){
        System.out.println("我在吃"+this.fruit.getName());
    }
     
    /*
     * @PostConstruct表示Spring容器初始化后调用
     */
    @PostConstruct
    public void eatBegin(){
        System.out.println("我要开始吃了");
    }
     
    /*
     * @PreDestroy表示Spring容器销毁之前调用
     */
    @PreDestroy
    public void eatFinish(){
        System.out.println("吃完了");
    }
}

5.测试类

/**
 * 测试类
 * 
 * @author ChenST
 *
 */
public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        Human human=(Human) ctx.getBean("human");
        human.eat();
    }
}

5.applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       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">
     
    <!-- 自动注解配置 -->
    <context:annotation-config />
    <context:component-scan base-package="*" />
</beans>

6.运行结果

我要开始吃了
我在吃苹果
吃完了

Spring中进行测试-Junit框架的扩展

利用Spring来进行测试。首先看看下面几个类。【参照网上的资料】

1.AbstractSpringContextTests 类是针对所有测试情景的类，一般不使用，而是使用他们的之类。

2.AbstractDependencyInjectionSpringContextTests 类继承了AbstractSpringContextTests类是一个针对所有测试的超类，具体依赖于Spring上下文。可支持依赖注入。

3.AbstractTransactionalSpringContextTests 类继承了AbstractDependencyInjectionSpringContextTests类，继承该类的测试用例在spring管理的事务中进行，测试完后对数据库的记录不会造成任何影响。你对数据库进行一些操作后，它会自动把数据库回滚，这样就保证了你的测试对于环境没有任何影响。

测试用例需实现protected abstract String[] getConfigLocations()方法来获取上下文。

1.创建一个测试类的基类

/**
 * Spring测试的基类
 * 
 * @author ChenST
 *
 */
public abstract class BaseSpringTest extends AbstractDependencyInjectionSpringContextTests {
     
    /**
     * 获取上下文spring context,该路径是在classpath下的路径
     */
    public String[] getConfigLocations() {
        String[] configLocations = { "applicationContext.xml" };
        return configLocations;
    }
}

2.测试用例

/**
 * 测试用例,测试Dao的方法getUserInfo(String userCode)
 * 
 * @author ChenST
 *
 */
public class UsersDaoTest extends BaseSpringTest {
     
    /** 用户Dao,注入实现 */
    private UsersDAO userDao;
     
    public void setUserDao(UsersDAO userDao) {
        this.userDao = userDao;
    }
 
    /**
     * 测试getUserInfo()方法,需要以test开头
     */
    public void testGetUserInfo(){
        Users user=userDao.getUserInfo("004");
        System.out.println(user.getDepartment().getDepName());
    }
}

可通过MyEclipse中的Outline透视图中进行单个方法的测试或者整个类的测试。

◎筱米加步枪◎.Blog

Happy coding