java注解的使用——摒弃xml，以注解的方式来实现BeanFactory

最新推荐文章于 2024-08-12 23:01:19 发布
最新推荐文章于 2024-08-12 23:01:19 发布
阅读量580 收藏
点赞数
分类专栏： java开发 文章标签： java注解 BeanFactory 注解使用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangxvwang/article/details/100586967
版权

历史的车轮永无止境的向前推进，碾压着万物生灵的每一天。

 前一篇文章讲述了从new对象到xml配置文件初始化对象，这一篇文章将会抛弃复杂的xml配置，直接使用注解来初始化我们简单的BeanFactory。

本篇涉及知识点 ：

 接下来先看一下本次代码的目录结构，如下：

说明一下类的情况：Bean和ScanPath是两个自定义注解，infos包下面是用来测试的JavaBean，BeanFactory是一个接口，他的直接实现子类是AnnotationBeanFactory。

Bean注解源码如下:

package bean.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;
/** Bean注解 @author 大灰狼 */
@Documented
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface Bean {
	/** 单例模式 */
	String SINGLETON = "singleton";
	/** 原型模式 */
	String PROTOTYPE = "prototype";
	/** bean的别名，可以是多个 */
	String[] name();
	/** bean创建完成后调用的方法，默认为无方法 */
	String initMethod() default "";
	String scope() default SINGLETON;
}

注解定义相关的请参考前面的涉及知识点链接文章

ScanPath注解源码如下:

package bean.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;

/** 定义自动扫描注解的路径，用于启动配置 */
@Documented
@Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface ScanPath {
	/** 基础路径,例如配置为{bean}则会扫描bean下面的所有类与子包的类 */
	String[] basePath() default "";
}

infos包下面java源码，

package bean.infos;

import bean.ExtUtil;
import bean.annotation.Bean;

/** 操作人 */
@Bean(name = { "optUser" }, scope = Bean.SINGLETON)
public class OptUser {
	private int age = ExtUtil.rnd.nextInt(100);
	private String name = ExtUtil.randStr(3);

	@Override
	public String toString() {
		return "【" + name + "," + age + "岁】";
	}
}

操作用户javaBean，里面的字段都是随机生成的，该类是用来测试字段注入的。单例模式

Car类源码:

package bean.infos;

import bean.ExtUtil;
import bean.annotation.Bean;

/** 小汽车，单例模式 */
@Bean(name = { "myCar", "yourCar" }, initMethod = "init")
public class Car {
	/** 制造 */
	private String madeBy = ExtUtil.randStr(3);

	/** 无参方法，用于测试initMethod */
	public void init() {
		System.out.println(this + "init");
	}

	public void showInfo() {
		System.out.println("beanInfo" + this + "====>制造作人:" + madeBy);
	}
}

默认单例模式，这里定义了两个别名。 

Train类源码:

package bean.infos;

import javax.annotation.Resource;

import bean.ExtUtil;
import bean.annotation.Bean;

/** 火车,原型模式 */
@Bean(name = { "myTrain" }, scope = Bean.PROTOTYPE)
public class Train {
	/** 目的地 */
	private String dest = ExtUtil.randStr(5);

	/** 操作人 */
	@Resource(name = "optUser")
	private OptUser optUser;

	public void setOptUser(OptUser optUser) {
		this.optUser = optUser;
	}

	public void showInfo() {
		System.out.println("beanInfo" + this + "==>操作人:" + optUser + ",目的地：" + dest);
	}
}

原型模式，optUser加了@Resource注解。

接下来是我们的工具类

package bean;

import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.LinkedBlockingQueue;

/** 扩展工具类 */
public class ExtUtil {
	final static String baseStr = "国年着就那和要她出也得里后自以会家可下而过天去能对小多然于心学么之都好看起发";
	public final static Random rnd = new Random();

	/**根据基础路径获取该路径下的所有class文件 */
	public static List<String> getAllClassByPackage(String... basePkg) throws Exception {
		List<String> classList = new ArrayList<String>();
		for (String basePath : basePkg) {
			String sysPath = basePath.replaceAll("\\.", "/");
			URL bsePath = ExtUtil.class.getClassLoader().getResource(sysPath);
			File f = new File(bsePath.getFile());
			if (!f.exists())
				throw new RuntimeException("指定路径不存在！");
			// 相对位置
			String root = f.getPath().replace(sysPath.replace("/", "\\"), "");
			Queue<File> dirs = new LinkedBlockingQueue<File>();
			dirs.add(f);
			for (;;) {
				File nextFile = dirs.poll();
				Arrays.asList(nextFile.listFiles()).forEach(file -> {
					if (file.isDirectory()) {
						dirs.add(file);
					} else {
						String filePath = file.getAbsolutePath();
						String classPath = filePath.replace(root, "").replaceAll("\\\\", "\\.");
						classList.add(classPath.substring(0, classPath.length() - ".Class".length()));
					}
				});
				if (dirs.isEmpty())
					break;
			}
		}
		return classList;
	}

	/** 字符串 */
	public static String randStr(int size) {
		StringBuffer buffer = new StringBuffer();
		for (int i = 0; i < size; i++) {
			buffer.append((char) baseStr.charAt(rnd.nextInt(baseStr.length() - 1)));
		}
		return buffer.toString();
	}

	/** 简单的将字段名称转成set方法 */
	public static String toSetMethodName(String fieldName) {
		String strHead = fieldName.substring(0, 1);
		StringBuffer buffer = new StringBuffer("set");
		buffer.append(fieldName.replace(strHead, strHead.toUpperCase()));
		return buffer.toString();
	}
}

然后是我们定义的BeanFactory和其直接实现子类

package bean;

public interface BeanFactory {

	/** 根据别名获取Bean实例 */
	Object getBean(String name) throws Exception;

	/** 根据别名和指定类型获取Bean */
	<T> T getBean(String name, Class<T> classType) throws Exception;
}
package bean;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import javax.annotation.Resource;
import bean.annotation.Bean;
import bean.annotation.ScanPath;

/** 基于注解的BeanFactory实现 */
public class AnnotationBeanFactory implements BeanFactory {

	final static ClassLoader loader = AnnotationBeanFactory.class.getClassLoader();

	/** Bean定义缓存 */
	private Map<String, BeanInfo> beanCache = new ConcurrentHashMap<>();

	/** 初始化BeanFactory，这里只根据@ScanPath 配置路径扫描@Bean注解的类 */
	public static synchronized AnnotationBeanFactory initFactory(Class<?> mainClass) throws Exception {
		AnnotationBeanFactory beanFactory = new AnnotationBeanFactory();
		ScanPath scan = mainClass.getAnnotation(ScanPath.class);
		if (scan == null)
			throw new Exception(mainClass.getName() + "未配置@ScanPath");
		ExtUtil.getAllClassByPackage(scan.basePath()).forEach(p -> {
			try {
				// 加载类并获取注解配置
				Class<?> cls = loader.loadClass(p);
				Bean anno = cls.getAnnotation(Bean.class);
				// 初始化@Bean注解类
				if (anno != null) {
					BeanInfo bi = beanFactory.initBeanInfo(cls, anno);
					for (String als : anno.name()) {
						beanFactory.beanCache.put(als, bi);
					}
				}
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
		});
		return beanFactory;
	}

	@Override
	public Object getBean(String name) throws Exception {
		return beanCache.get(name).getBean();
	}

	@Override
	public <T> T getBean(String name, Class<T> classType) throws Exception {
		return beanCache.get(name).getBean(classType);
	}

	/** 初始化指定bean信息 */
	private BeanInfo initBeanInfo(Class<?> cls, Bean anno) {
		try {
			return new BeanInfo(cls, Bean.PROTOTYPE.equals(anno.scope()));
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	/** Bean信息定义 */
	class BeanInfo {
		public final Class<?> cls;
		/** 是否原型模式 */
		public final boolean isPrototype;
		/** 对象实例，如果是单例模式直接返回该对象 */
		public final Object inst;
		/** 需要注入的字段[字段名称，注入的对象别名] */
		public final List<String[]> diField = new ArrayList<String[]>();

		/** 构造函数 */
		public BeanInfo(Class<?> cls, boolean isPrototype) throws Exception {
			this.cls = cls;
			this.isPrototype = isPrototype;
			this.inst = cls.newInstance();
			// 这里只解析一下@Resource注解，以便我们可以注入该信息
			for (Field next : cls.getDeclaredFields()) {
				Resource rs = next.getAnnotation(Resource.class);
				if (rs != null) {
					diField.add(new String[] { next.getName(), rs.name() });
				}
			}
		}

		public Object getBean() throws Exception {
			if (!isPrototype) {
				return inst;
			}
			// 这里需要注意，如果是原型模式，则检查是否有需要注入的字段
			Object pinst = cls.newInstance();
			for (String[] diInfo : diField) {
				String methodName = diInfo[0], ansName = diInfo[1];
				BeanInfo argBean = beanCache.get(ansName);
				Method mtd = cls.getMethod(ExtUtil.toSetMethodName(methodName), argBean.cls);
				mtd.invoke(pinst, argBean.getBean());
			}
			return pinst;
		}

		@SuppressWarnings("unchecked")
		public <T> T getBean(Class<T> t) throws Exception {
			return (T) getBean();
		}
	}
}

最后是我们的测试类：

package bean;

import bean.annotation.ScanPath;
import bean.infos.Car;
import bean.infos.Train;

/** 测试基于注解的BeanFactory */
@ScanPath(basePath = { "bean" })
public class TestApp {

	public static void main(String[] args) throws Exception {
		// 启动解析注解
		AnnotationBeanFactory factory = AnnotationBeanFactory.initFactory(TestApp.class);
		if (factory != null) {
			factory.getBean("myCar", Car.class).showInfo();
			factory.getBean("yourCar", Car.class).showInfo();
			factory.getBean("myTrain", Train.class).showInfo();
			factory.getBean("myTrain", Train.class).showInfo();
		}
	}
}

运行结果如下：

beanInfobean.infos.Car@5fd0d5ae====>制造作人:会和去
beanInfobean.infos.Car@5fd0d5ae====>制造作人:会和去
beanInfobean.infos.Train@2d98a335==>操作人:【么可年,90岁】,目的地：那要国里那
beanInfobean.infos.Train@16b98e56==>操作人:【么可年,90岁】,目的地：看会学多要

运行结果分析：

两次Car的获取和输出信息是一致的，说明返回的是同一个实例，两次Train输出的对象信息不一致，而OptUser信息一致，说明Train返回的是单例，OptUser不是单例。

修改Train类的scope 为单例：

再次运行结果如下:

beanInfobean.infos.Car@5fd0d5ae====>制造作人:过下天
beanInfobean.infos.Car@5fd0d5ae====>制造作人:过下天
beanInfobean.infos.Train@2d98a335==>操作人:null,目的地：都自那就和
beanInfobean.infos.Train@2d98a335==>操作人:null,目的地：都自那就和

两次Train输出的对象信息一致，而OptUser为null，说明没有找到optUser别名的对象，其实这是本次BeanFactory的一个bug，因为在创建Train单例模式的时候OptUser对象还没有生成，所以去获取的时候为null。修复该bug其实也很简单，去掉final修饰，getBean()采用懒加载。

我们再次修改Train和OptUser都为原型模式做最后测试：

测试结果如下

beanInfobean.infos.Car@5fd0d5ae====>制造作人:要好对
beanInfobean.infos.Car@5fd0d5ae====>制造作人:要好对
beanInfobean.infos.Train@2d98a335==>操作人:【那就她,69岁】,目的地：得起年出和
beanInfobean.infos.Train@16b98e56==>操作人:【就看就,19岁】,目的地：以她过会会

最后可以看到Train和OptUser对象都是原型模式了。

Call Next
关注
专栏目录
Spring注解驱动开发第41讲——Spring IOC容器创建源码解析(一)之BeanFactory的创建以及预准备工作（合起
08-07
Spring注解驱动开发第41讲——Spring IOC容器创建源码解析(一)之BeanFactory的创建以及预准备工作（合起来整个过程）
简单存 Bean 对象 -- 五大类注解以及 Bean 方法注解
这个人很懒, 什么都没留下(这是我写的)
04-24 1731
@Controller、@Service、@configuration、@Repository、@Component五大类注解以及@Bean方法注解, 更快的存储 Bean 对象
java开发常用注解详解
编程是一门实践技术
03-30 1292
java开发常用注解详解，只需这些就够了
Java中XML的解析
最新发布
SHI940637335的博客
08-12 3309
​ 当将数据存储在XML后，我们就希望通过程序获取XML的内容。如果我们使用Java基础所学的IO知识是可以完成的，不过你学要非常繁琐的操作才可以完成，且开发中会遇到不同问题（只读、读写）。人们为不同问题提供不同的解析方式，使用不同的解析器进行解析，方便开发人员操作XML。XML DOM 和 HTML DOM一样，XML DOM 将整个XML文档加载到内存，生成一个DOM树，并获得一个Document对象，通过Document对象就可以对DOM进行操作。以下面books.xml文档为例。
【Java】Spring ——用【注解】更快捷的存储 / 获取Bean对象
The_emperoor_man的博客
07-30 1357
本文详细介绍了如何使用注解更快捷便利的存储获取Bean对象！
注解方式声明bean
qq_43038960的博客
05-08 290
`bean` 代指的就是那些被 IoC 容器所管理的对象。我们需要告诉 IoC 容器帮助我们管理哪些对象，可以是 XML 文件、注解或者 Java 配置类，目前常用的为注解方式声明 bean，有以下几种方式：
Spring核心注解深入解析：提升开发效率
12-13
`@Configuration`注解的类表示配置元数据，而`@Bean`注解的方法则声明了一个bean的定义，使得开发者可以通过编程的方式来定义和管理Spring容器中的bean。 `@Value`注解提供了注入简单类型属性的能力，如字符串、...
java使用dom4j解析xml配置文件实现抽象工厂反射示例
09-04
在这个例子中，`BeanFactory`使用DOM4J的`SAXReader`来解析XML文档，获取`service-class`和`dao-class`下的所有元素。这些元素代表了工厂需要生产的对象，即接口的实现类。工厂将创建的对象存储在一个Map中，以便...
使用BeanFactory实现创建对象
08-27
使用BeanFactory实现创建对象 BeanFactory是一种工厂模式，主要用来创建对象。在Java中，BeanFactory是Spring框架中的一个核心组件，用于管理和创建对象。通过使用BeanFactory，可以将对象的创建和依赖注入解耦，...
java 使用JDOM解析xml文件
09-05
在Java中，JDOM库提供了一种方便的方式来解析XML文件，它将XML文档转换成一个可操作的Java对象模型。JDOM允许开发者通过API直接操作XML元素、属性和文本，而无需关注底层的SAX或DOM解析机制。本教程将介绍如何使用...
spring注解
qq_50792353的博客
10-26 422
** 1.基础(SpringMVC和SpringBoot都有在用)** @Controller 通常用于标注在控制层类上。 @Service 通常用于标注在业务层实现类上。可以设置自定义service类的别名，在控制层引入时就需要根据设置的别名进行引入。 @Mapper 不需要在启动类上配置扫描，会在运行时通过动态代理生成实现类。 @Component 泛指组件，当组件不好归属于控制层/业务层 的时候，我们可以使用这个注解进行标注 @ServletComponentScan 在SpringBootAppli
更简单的存取Bean方式-@Bean方法注解
chenchenchencl的博客
04-25 2991
类注解是添加在某个类上的,那么方法注解是添加在某个方法前的当我们使用测试类去获取Bean时,发现获取不到图一无法正确拿到Bean的原因:原因一:@Bean命名规则和不打雷注解的命名规则不同,@Bean存储的对象的命名默认是方法的名称此时改动对象名称为user1(方法名),发现还是会报错原因二:方法注解是要配合五大类注解使用注意:无法获取到对象的原因有两个,名称必须是方法名且方法注解需要配合五大类注解名称不能换成类名, 对象名等,加上五大类注解也不能成功获取到!!
【Java第31期】：Spring中存储Bean的注解以及用法
m0_62262008的博客
11-19 976
Spring中是如何存储Bean的？一篇文章带你揭开其神秘面纱~
Java_XML，注解
qq_38175040的博客
02-28 278
Override 代表方法重写的注解，子类对父类中的某个方法进行的重写，首先方法名要与父类中的方法名保持一致，其次在子类中的重写函数的上方添加@Override代表提示这个方法是一个重写的方法。然后用下面这段代码读取xml，接近于源码，框架中应该可以直接使用。一些@author,@param的注解暂时掠过。解析XML可以用一个叫dom的工具。把jar包放到项目lib目录下。
Bean的存取、五大注解、对象的注入方式、Bean的作用域和生命周期
qq_56324572的博客
05-11 1640
PS：Java语言中的对象也叫作 Bean。PS：要在 pom.xml 中添加 spring 框架支持启动类（包含main方法即可）：创建bean：配置文件： 注册bean：类注解：@Controller、@Service、@Repository、@Component、@Configuration注解的作用：便于直接了解类的作用。1.1.1、@Controller（控制器）——表示的是业务逻辑层，接口的最外层，验证参数接口的正确性或者参数的转换、返回。存储 bean：读取 bean： 1.1.2、@Se
@Bean注解的使用和详解
热门推荐
学源客的博客
03-16 5万+
@Bean：Spring的@Bean注解用于告诉方法，产生一个Bean对象，然后这个Bean对象交给Spring管理。产生这个Bean对象的方法Spring只会调用一次，随后这个Spring将会将这个Bean对象放在自己的IOC容器中。 SpringIOC 容器管理一个或者多个bean，这些bean都需要在@Configuration注解下进行创建，在一个方法上使用@Bean注解就表明这个方法需...
Bean与@Bean注解
llg___的博客
06-27 422
Spring的@Bean注解用于告诉方法，产生一个Bean对象，然后这个Bean对象交给Spring管理。产生这个Bean对象的方法Spring只会调用一次，随后这个Spring将会将这个Bean对象放在自己的IOC容器中。Ioc容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在Ioc容器中统称`Bean。@Bean放在方法上，告诉被注解的方法，你去产生一个Bean，然后交给Spring容器管理。使用对象时，在程序中不要主动使用new产生对象，转换为由外部提供对象。基于上面的问题，我们考虑。
JavaSE注解与XML基础
qq_64388611的博客
11-26 287
无
Bean 注解全解析
m0_57229961的博客
01-26 5541
@Bean 注解全解析 随着SpringBoot的流行，基于注解式开发的热潮逐渐覆盖了基于XML纯配置的开发，而作为Spring中最核心的bean当然也能够使用注解的方式进行表示。所以本篇就来详细的讨论一下作为Spring中的Bean到底都有哪些用法。 @Bean 基础声明 Spring的@Bean注解用于告诉方法，产生一个Bean对象，然后这个Bean对象交给Spring管理。产生这个Bean对象的方法Spring只会调用一次，随后这个Spring将会将这个Bean对象放在自己的IOC容器中。 S
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值