目录
2.2练习二判断一个类和属性是否包含某一个注解以及获取注解的value
1.什么是IOC
IOC（Inversion of Control），控制反转。
就是指将对象的创建，对象的存储(map)，对象的管理(依赖查找,依赖注入)交给了spring容器。
最要要的作用就是解耦合
2.IOC入门小练习（开口小菜）
2.1 基于properties配置文件方式
properties配置文件
pojo=cn.tedu.test.Pojo上代码
具体的实现类
package cn.tedu.myspring_two;
import cn.tedu.test.Pojo;
import java.io.FileInputStream;
import java.util.Properties;
/**
* 基于properties配置文件方式 获取bean
*/
public class TestSpring {
public static void main(String[] args) {
try {
Properties properties = new Properties();//properties属于map集合 存方的都是key=value的形式
properties.load(new FileInputStream("src\\cn\\tedu\\myspring_two\\spring.properties"));//读入properties文件
String pojo = properties.getProperty("pojo");//获取key为pojo的对象
Class<?> aClass = Class.forName(pojo);//通过反射获取字节码文件
Object o = aClass.newInstance();//将字节码文件实例化
Pojo o1 = (Pojo) o;//强转成为子类类型
System.out.println(o1);
}catch (Exception e){
e.printStackTrace();
}
}
}
2.2练习二判断一个类和属性是否包含某一个注解以及获取注解的value
上代码
自定义Aut注解
package cn.tedu.myspring_three;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Aut {
String value()default "Aut";
}
自定义Service注解
package cn.tedu.myspring_three;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Service {
String value() default "service";
}
创建测试类SpringTest
package cn.tedu.myspring_three;
import java.lang.reflect.Field;
public class SpringTest {
public void method() throws ClassNotFoundException {
Class<?> aClass = Class.forName("cn.tedu.myspring_three.Student");//获取字节码文件
if (aClass.isAnnotationPresent(Service.class)) {//判断字节码是否办函Service类
System.out.println("这个类包含Service注解");
}
Field[] declaredFields = aClass.getDeclaredFields();//获取私有属性
for (Field declaredField : declaredFields) {//遍历私有属性
if (declaredField.isAnnotationPresent(Aut.class)) {//判断属性上是否包含Aut注解
System.out.println(declaredField.getName()+"属性包含"+"Aut"+"注解");
}else {
System.out.println(declaredField.getName() + "属性" + "不包含Aut注解");
}
}
}
public static void main(String[] args) throws ClassNotFoundException {//测试
new SpringTest().method();
}
}
3，手敲IOC容器以及DI（正片开始）
创建自定义注解CGB
package cn.tedu.myspring;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface CGB {
String value() default"";
}
自定义value注解
package cn.tedu.myspring;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface value {
String value()default "";
}
创建工具类MyTools，用来获取包里面的所有类的字节码
package cn.tedu.myspring;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
/**
* 本类是一个扫描报的工具类
*/
public class MyTools {
public static Set<Class<?>> getClasses(String pack) {
// 第一个class类的集合
Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
// 是否循环迭代
boolean recursive = true;
// 获取包的名字 并进行替换
String packageName = pack;
String packageDirName = packageName.replace('.', '/');
// 定义一个枚举的集合 并进行循环来处理这个目录下的things
Enumeration<URL> dirs;
try {
dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
// 循环迭代下去
while (dirs.hasMoreElements()) {
// 获取下一个元素
URL url = dirs.nextElement();
// 得到协议的名称
String protocol = url.getProtocol();
// 如果是以文件的形式保存在服务器上
if ("file".equals(protocol)) {
// 获取包的物理路径
String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
// 以文件的方式扫描整个包下的文件 并添加到集合中
findClassesInPackageByFile(packageName, filePath, recursive, classes);
} else if ("jar".equals(protocol)) {
// 如果是jar包文件
// 定义一个JarFile
System.out.println("jar类型的扫描");
JarFile jar;
try {
// 获取jar
jar = ((JarURLConnection) url.openConnection()).getJarFile();
// 从此jar包 得到一个枚举类
Enumeration<JarEntry> entries = jar.entries();
findClassesInPackageByJar(packageName, entries, packageDirName, recursive, classes);
} catch (IOException e) {
// log.error("在扫描用户定义视图时从jar包获取文件出错");
e.printStackTrace();
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
return classes;
}
private static void findClassesInPackageByJar(String packageName, Enumeration<JarEntry> entries, String packageDirName, final boolean recursive, Set<Class<?>> classes) {
// 同样的进行循环迭代
while (entries.hasMoreElements()) {
// 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
JarEntry entry = entries.nextElement();
String name = entry.getName();
// 如果是以/开头的
if (name.charAt(0) == '/') {
// 获取后面的字符串
name = name.substring(1);
}
// 如果前半部分和定义的包名相同
if (name.startsWith(packageDirName)) {
int idx = name.lastIndexOf('/');
// 如果以"/"结尾 是一个包
if (idx != -1) {
// 获取包名 把"/"替换成"."
packageName = name.substring(0, idx).replace('/', '.');
}
// 如果可以迭代下去 并且是一个包
if ((idx != -1) || recursive) {
// 如果是一个.class文件 而且不是目录
if (name.endsWith(".class") && !entry.isDirectory()) {
// 去掉后面的".class" 获取真正的类名
String className = name.substring(packageName.length() + 1, name.length() - 6);
try {
// 添加到classes
classes.add(Class.forName(packageName + '.' + className));
} catch (ClassNotFoundException e) {
// .error("添加用户自定义视图类错误 找不到此类的.class文件");
e.printStackTrace();
}
}
}
}
}
}
private static void findClassesInPackageByFile(String packageName, String packagePath, final boolean recursive, Set<Class<?>> classes) {
// 获取此包的目录 建立一个File
File dir = new File(packagePath);
// 如果不存在或者 也不是目录就直接返回
if (!dir.exists() || !dir.isDirectory()) {
// log.warn("用户定义包名 " + packageName + " 下没有任何文件");
return;
}
// 如果存在 就获取包下的所有文件 包括目录
File[] dirfiles = dir.listFiles(new FileFilter() {
// 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
@Override
public boolean accept(File file) {
return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
}
});
// 循环所有文件
for (File file : dirfiles) {
// 如果是目录 则继续扫描
if (file.isDirectory()) {
findClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive, classes);
} else {
// 如果是java类文件 去掉后面的.class 只留下类名
String className = file.getName().substring(0, file.getName().length() - 6);
try {
// 添加到集合中去
// classes.add(Class.forName(packageName + '.' +
// className));
classes.add(Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));
} catch (ClassNotFoundException e) {
// log.error("添加用户自定义视图类错误 找不到此类的.class文件");
e.printStackTrace();
}
}
}
}
}
IOC DI具体实现逻辑
package cn.tedu.myspring;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class MyClassPathXMLApplicationContext {
private HashMap<String, Object> hashMap = new HashMap();
private Set<Class> set = new HashSet();
/**
* 对外提供一个代参的构造器，pakge为传入的包名的路径
* 将包内所有的字节码文件获取，筛选出包含自定义注解的字节码文件放入Set集合中
* 为什么要采用set集合呢？因为set集合中的元素具有不可重复性，保证字节码的唯一性
* 调用get方法将带有表示的类实例化，并对注解的值进行判断，如果注解有值，当做key存入map
* 如果没有值首字母小写当做key存入map
* get方法调用add()方法，实现对属性的注入
*
* @param pakge
*/
public MyClassPathXMLApplicationContext(String pakge) {
Set<Class<?>> classes = MyTools.getClasses(pakge);//获取所有的字节码文件
Iterator<Class<?>> iterator = classes.iterator();//获取set集合的迭代器准备将set集合中的字节码文件迭代出来
while (iterator.hasNext()) {//开始迭代
Class<?> next = iterator.next();//获取当前指针的元素，并将指针下移
if (next.isAnnotationPresent(CGB.class)) {//判断当前字节码文件TYPE属性上是否有自己定义的CGB注解
set.add(next);//如果包含自定义的CGB注解调用set集合的add()方法，将字节码文件放入set集合
}
}
try {
get();//调用get方法 将对象放入map集合中
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 将带有表示的类实例化，并对注解的值进行判断，如果注解有值，当做key存入map
* 如果没有值首字母小写当做key存入map，调用自定义的add()方法对属性进行赋值
*
* @throws Exception
*/
private void get() throws Exception {
Class next = null;
Object o = null;
Iterator<Class> iterator = set.iterator();//迭代包含自定义注解的字节码文件
while (iterator.hasNext()) {
next = iterator.next();//获取当前字节码文件，并将指针下移
o = next.newInstance();//将字节码文件实例化
CGB annotation = (CGB) next.getAnnotation(CGB.class);//类上的注解，并将注解强制转换成自定义注解类型
String value = annotation.value();//获取注解的value值
if (value.equals("")) {//对注解的值进行判断，是否为空，为空则将类名小写作为key放入map集合当中
String simpleName = next.getSimpleName();//通过当前类的字节码文件获取当前类名
String s = simpleName.substring(0, 1).toLowerCase() + simpleName.substring(1, simpleName.length());//将类名首字母变成小写
hashMap.put(s, o);//放入map集合
} else {
hashMap.put(value, o);//如果当前注解的value不为空，直接存入map集合
}
}
add(next, o);//调用add()方法实现对包含赋值注解的属性的赋值操作
}
/**
* 对属性进行赋值
*
* @param clazz 要赋值的类的字节码文件
* @param o 字节码实例化的对象
* @param <T>代表字节码类的类型
* @throws Exception
*/
private <T> void add(Class<T> clazz, Object o) throws Exception {
synchronized (MyClassPathXMLApplicationContext.class) {
Field[] declaredFields = clazz.getDeclaredFields();//通过暴力反射获取所有的属性
for (Field declaredField : declaredFields) {//对属性进行遍历操作
if (declaredField.isAnnotationPresent(value.class)) {//如果当前属性上包含自定义的value注解
value annotation = declaredField.getAnnotation(value.class);//获取属性上value注解的对象
String value = annotation.value();//获取value注解的值
Class<?> type1 = declaredField.getType();//获取当前属性的类型的字节码文件
String s1 = String.valueOf(type1);//将字节码文件转换成字符串
switch (s1) {//对s1进行比较
case "class java.lang.Integer"://如果是Integer类型
Integer a = Integer.valueOf(value);//将String字符串转换成Integer类型
declaredField.setAccessible(true);//将私有属性设置可见
declaredField.set((T) o, a);//通过暴力反射获取属性 以下类似不过多注释
break;
case "class java.lang.String":
declaredField.setAccessible(true);
declaredField.set((T) o, value);
break;
case "class java.lang.Double":
Double b = Double.valueOf(value);
declaredField.setAccessible(true);
declaredField.set((T) o, b);
break;
case "class java.lang.Float":
Float c = Float.valueOf(value);
declaredField.setAccessible(true);
declaredField.set((T) o, c);
break;
case "class java.lang.Character":
if (value.length() == 1) {
declaredField.setAccessible(true);
declaredField.set((T) o, value.toCharArray()[0]);
} else {
throw new Exception();
}
break;
case "class java.lang.Byte":
Byte e = Byte.valueOf(value);
declaredField.setAccessible(true);
declaredField.set((T) o, e);
break;
case "class java.lang.Short":
Short f = Short.valueOf(value);
declaredField.setAccessible(true);
declaredField.set((T) o, f);
break;
case "class java.lang.Long":
Long fg = Long.valueOf(value);
declaredField.setAccessible(true);
declaredField.set((T) o, fg);
break;
case "class java.lang.Boolean":
Boolean aBoolean = Boolean.valueOf(value);
declaredField.setAccessible(true);
declaredField.set((T) o, aBoolean);
break;
default:
//如果类型为引用数据类型执行default里面的内容
declaredField.setAccessible(true);//将私有属性设置可见
if (value.equals("")) {//如果value注解的值为默认值执行此分支
String s = declaredField.getName().substring(0, 1).toLowerCase() + declaredField.getName().substring(1, declaredField.getName().length());
add(getBean(s).getClass(), getBean(s));//递归本方法将将引用数据类型中包含自定义注解value的属性进行赋值
declaredField.set((T) o, getBean(s));//对属性进行赋值
}else {
add(getBean(value).getClass(), getBean(value));//递归本方法将将引用数据类型中包含自定义注解value的属性进行赋值
declaredField.set((T) o, getBean(value));//对属性进行赋值
}
}
}
}
}
}
/**
* 提供的获取对象的方法
*
* @param id
* @return
*/
public Object getBean(String id) {
return hashMap.get(id);
}
}
创建Pojo类用于作为封装类
package cn.tedu.test;
import cn.tedu.myspring.CGB;
import cn.tedu.myspring.value;
@CGB
public class Pojo {
@value("张三")
private String name;
@value("13")
private Integer age;
@value("pojo1")
private Pojo1 pojo1;
@Override
public String toString() {
return "Pojo{" +
"name='" + name + '\'' +
", age=" + age +
", pojo1=" + pojo1 +
'}';
}
}
创建Pojo1 类用于作为封装类
package cn.tedu.test;
import cn.tedu.myspring.CGB;
import cn.tedu.myspring.value;
@CGB
public class Pojo1 {
@value("中行收")
private String name;
@value("121")
private Integer age;
@value("pojo2")
private Pojo2 pojo2;
@Override
public String toString() {
return "Pojo1{" +
"name='" + name + '\'' +
", age=" + age +
", pojo2=" + pojo2 +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
创建Pojo2类用于封装类
package cn.tedu.test;
import cn.tedu.myspring.CGB;
import cn.tedu.myspring.value;
@CGB
public class Pojo2 {
@value("李四")
private String name;
@value("99")
private Integer age;
@Override
public String toString() {
return "Pojo2{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
创建Test类测试数据
package cn.tedu.test;
import cn.tedu.myspring.CGB;
import cn.tedu.myspring.MyClassPathXMLApplicationContext;
@CGB
public class Test {
public static void main(String[] args) {
MyClassPathXMLApplicationContext m = new MyClassPathXMLApplicationContext("cn.tedu.test");
System.out.println(m.getBean("pojo"));
}
}
运行结果
相信你敲完之后会对注解反射以及Spring Ioc会有新的理解
214
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
