ioc构架demo

1、视图

 1 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 2     xmlns:tools="http://schemas.android.com/tools"
 3     android:layout_width="match_parent"
 4     android:layout_height="match_parent"
 5        android:orientation="vertical"
 6     >
 7
 8     <Button
 9         android:id="@+id/btn_login"
10         android:layout_width="fill_parent"
11         android:layout_height="wrap_content"
12         android:text="登陆" />
13     <Button
14         android:id="@+id/btn_register"
15         android:layout_width="fill_parent"
16         android:layout_height="wrap_content"
17         android:text="注册" />
18
19 </LinearLayout>

2、MainActivity

 1 package com.zyh.zyh_ioc;
 2
 3 import android.os.Bundle;
 4 import android.util.Log;
 5 import android.view.View;
 6 import android.widget.Button;
 7
 8 import com.zyh.ioc.annotation.ContentView;
 9 import com.zyh.ioc.annotation.OnClick;
10 import com.zyh.ioc.annotation.ViewInject;
11 import com.zyh_ioc.activity.BaseActivity;
12 import android.widget.Toast;
13
14 @ContentView(R.layout.activity_main)
15 public class MainActivity extends BaseActivity {
16     @ViewInject(R.id.btn_login)
17     private Button btnLogin;
18
19     @ViewInject(R.id.btn_register)
20     private Button btnRegister;
21
22     @Override
23     protected void onCreate(Bundle savedInstanceState) {
24         super.onCreate(savedInstanceState);
25         Log.i("zyh",btnLogin.getText().toString() + "," + btnRegister.getText().toString());
26     }
27
28     @OnClick({R.id.btn_login,R.id.btn_register})
29     public void Toast(View btn){
30         switch(btn.getId()){
31             case R.id.btn_login:
32                 Toast.makeText(this, "登陆", Toast.LENGTH_SHORT).show();
33                 break;
34             case R.id.btn_register:
35                 Toast.makeText(this, "注册", Toast.LENGTH_SHORT).show();
36                 break;
37             default:
38                 break;
39         }
40     }
41 }

3、BaseActivity

 1 package com.zyh_ioc.activity;
 2
 3 import com.zyh.ioc.utils.InjectUtils;
 4
 5 import android.app.Activity;
 6 import android.os.Bundle;
 7
 8 public class BaseActivity extends Activity {
 9     @Override
10     protected void onCreate(Bundle savedInstanceState) {
11         super.onCreate(savedInstanceState);
12         InjectUtils.inject(this);
13     }
14 }

4、InjectUtils

  1 package com.zyh.ioc.utils;
  2
  3 import com.zyh.ioc.annotation.ContentView;
  4 import com.zyh.ioc.annotation.EventBase;
  5 import com.zyh.ioc.annotation.OnClick;
  6 import com.zyh.ioc.annotation.ViewInject;
  7 import com.zyh.ioc.proxy.ListenerInvocationHandler;
  8
  9 import android.app.Activity;
 10 import android.view.View;
 11
 12 import java.lang.annotation.Annotation;
 13 import java.lang.reflect.Field;
 14 import java.lang.reflect.Method;
 15 import java.lang.reflect.Proxy;
 16
 17 //===============================================
 18 //类的Annotation需要类对象来获取
 19 //方法的Annotation需要方法对象来获取
 20 //属性的Annotation需要属性对象来获取
 21 //Annotation的Annotation需要Annotation的类对象来获取
 22 //===============================================
 23
 24 public class InjectUtils {
 25     public static void inject(Activity activity){
 26         injectContentView(activity);
 27         injectViews(activity);
 28         injectEvents(activity);
 29     }
 30
 31     /**
 32      * @desc 注入布局
 33      * @param activity
 34      */
 35     private static void injectContentView(Activity activity) {
 36         Class<? extends Activity> clazz = activity.getClass();
 37         ContentView contentView = clazz.getAnnotation(ContentView.class);
 38         int layoutId = contentView.value();
 39         activity.setContentView(layoutId);
 40     }
 41
 42     /**
 43      * @desc 注入控件
 44      * @param activity
 45      */
 46     private static void injectViews(Activity activity) {
 47         Class<? extends Activity> clazz = activity.getClass();
 48         Field[] fields = clazz.getDeclaredFields();
 49         for(Field field : fields){
 50             ViewInject viewInject = field.getAnnotation(ViewInject.class);
 51             if(viewInject != null){
 52                 //获取注解上的值
 53                 int viewId = viewInject.value();
 54                 Object view = activity.findViewById(viewId);//获取视图对象
 55                 try {
 56                     field.setAccessible(true);//表明私有的属性也可以设置值
 57                     field.set(activity, view);//给属性设值
 58                 } catch (Exception e) {
 59                     e.printStackTrace();
 60                 }
 61             }
 62         }
 63     }
 64
 65     /**
 66      * @desc 注入事件
 67      * @param activity
 68      */
 69     private static void injectEvents(Activity activity) {
 70         Class<? extends Activity> clazz = activity.getClass();
 71         Method[] methods = clazz.getMethods();
 72         for(Method method : methods){
 73             Annotation[] annotations = method.getAnnotations();
 74             for(Annotation annotation : annotations){
 75                 Class<? extends Annotation> annotationType = annotation.annotationType();//返回的是Annotation类对象
 76                 if(annotationType != null){
 77                     EventBase eventBase = annotationType.getAnnotation(EventBase.class);//获取注释的注释
 78                     if(eventBase != null){
 79                         String listenerSetter = eventBase.listenerSetter();//获取的设置监听事件的方法名
 80                         Class<?> listenerType = eventBase.listenerType();//获取监听事件的类对象
 81                         String methodName = eventBase.callBackMethod();//获取回调方法名
 82
 83                         //下面两行代码说明:得到Annotation实例就可以获取annotation括号里的内容
 84                         /*OnClick onClick = (OnClick) annotation;
 85                         int[] xxx = onClick.value();*/
 86                         try {
 87                             //这里是利用反射获取viewIds的值
 88                             Method valueMethod = annotationType.getDeclaredMethod("value");
 89                             int[] viewIds = (int[]) valueMethod.invoke(annotation, null);
 90
 91                             //设置代理
 92                             ListenerInvocationHandler handler = new ListenerInvocationHandler(activity);
 93                             //onClick->toast
 94                             handler.addMethod(methodName, method);
 95                             //通过Proxy产生一个listenerType类型的代理对象
 96                             //listener是一个onClickListener对象
 97                             Object listener = Proxy.newProxyInstance(listenerType.getClassLoader(), new Class<?>[]{listenerType}, handler);
 98
 99                             //多个按钮要注册监听
100                             for(int viewId : viewIds){
101                                 View view = activity.findViewById(viewId);
102
103                                 //获取setOnClickListener方法
104                                 Method setter = view.getClass().getMethod(listenerSetter, listenerType);
105                                 //注册
106                                 setter.invoke(view, listener);
107                             }
108                         } catch (Exception e) {
109                             e.printStackTrace();
110                         }
111                     }
112                 }
113             }
114         }
115     }
116 }

5、自定义的Annotation

1)布局的Annotation

 1 package com.zyh.ioc.annotation;
 2
 3 import java.lang.annotation.ElementType;
 4 import java.lang.annotation.Retention;
 5 import java.lang.annotation.RetentionPolicy;
 6 import java.lang.annotation.Target;
 7
 8 //指定注解使用的类的位置上
 9 @Target(ElementType.TYPE)
10
11 //编译程序将注解存储在class文件中,让虚拟机通过反射读入
12 @Retention(RetentionPolicy.RUNTIME)
13 public @interface ContentView {
14     int value();
15 }

2)findViewById的Annotation

 1 package com.zyh.ioc.annotation;
 2
 3 import java.lang.annotation.ElementType;
 4 import java.lang.annotation.Retention;
 5 import java.lang.annotation.RetentionPolicy;
 6 import java.lang.annotation.Target;
 7
 8 //指定使用在属性上
 9 @Target(ElementType.FIELD)
10
11 @Retention(RetentionPolicy.RUNTIME)
12 public @interface ViewInject {
13     int value();
14 }

3)点击事件的Annotation

 1 package com.zyh.ioc.annotation;
 2
 3 import java.lang.annotation.ElementType;
 4 import java.lang.annotation.Retention;
 5 import java.lang.annotation.RetentionPolicy;
 6 import java.lang.annotation.Target;
 7
 8 import android.view.View;
 9
10 @Target(ElementType.METHOD)
11 @Retention(RetentionPolicy.RUNTIME)
12 @EventBase(listenerSetter = "setOnClickListener",listenerType = View.OnClickListener.class,callBackMethod = "onClick")
13 public @interface OnClick {
14     int[] value();
15 }
 1 package com.zyh.ioc.annotation;
 2
 3 import java.lang.annotation.ElementType;
 4 import java.lang.annotation.Retention;
 5 import java.lang.annotation.RetentionPolicy;
 6 import java.lang.annotation.Target;
 7
 8 //说明在另外的注解上使用
 9 @Target(ElementType.ANNOTATION_TYPE)
10 @Retention(RetentionPolicy.RUNTIME)
11 public @interface EventBase {
12     /**
13      * @desc 例如:setOnClickListener的方法名称
14      * @return
15      */
16     String listenerSetter();
17
18     /**
19      * @desc 说明listener的类型
20      * @return
21      */
22     Class<?> listenerType();
23
24     /**
25      * @desc listener的回调方法名称
26      * @return
27      */
28     String callBackMethod();
29 }

6、代理类

 1 package com.zyh.ioc.proxy;
 2
 3 import java.lang.reflect.InvocationHandler;
 4 import java.lang.reflect.Method;
 5 import java.util.HashMap;
 6
 7 public class ListenerInvocationHandler implements InvocationHandler {
 8     private Object target;
 9
10     private HashMap<String, Method> methodMap = new HashMap<String, Method>();
11
12     public ListenerInvocationHandler(Object target) {
13         this.target = target;
14     }
15     @Override
16     public Object invoke(Object proxy, Method method, Object[] args)
17             throws Throwable {
18         if(target != null){
19             //执行的方法名称onClick
20             String methodName = method.getName();
21             //toast方法
22             Method method2 = methodMap.get(methodName);
23             if(method2 != null){
24                 method2.invoke(target, args);
25             }
26         }
27         return null;
28     }
29     public Object getTarget() {
30         return target;
31     }
32     public void setTarget(Object target) {
33         this.target = target;
34     }
35
36     /**
37      * @desc 绑定方法
38      * @param name
39      * @param method
40      */
41     public void addMethod(String name, Method method){
42         methodMap.put(name, method);
43     }
44 }
时间： 2025-01-05 23:34:30

ioc构架demo的相关文章

Spring入门IOC和AOP学习笔记

Spring入门IOC和AOP学习笔记 概述 Spring框架的核心有两个: Spring容器作为超级大工厂,负责管理.创建所有的Java对象,这些Java对象被称为Bean. Spring容器管理容器中Bean之间的依赖关系,使用一种叫做"依赖注入"的方式来管理bean之间的依赖关系. Spring有两个核心接口:BeanFactory和ApplicationContext,ApplicationContext是BeanFactory的子接口.它们都可以代表Spring容器,Spri

Spring.Net控制翻转、依赖注入、面向切面编程

Spring.Net快速入门:控制翻转.依赖注入.面向切面编程 Spring.Net主要功能: 1.IoC:控制翻转(Inversion of Control)  理解成抽象工厂翻转控制:就是创建对象的权利由开发人员自己控制New,转到了由容器来控制. 2.DI:依赖注入(Dependency Injection)依赖注入:就是在通过容器开创建对象的时候,在对象的初始化是可以给一些属性.构造方法的参数等注入默认值(可以是复杂的类型). 3.AOP:面向切面编程  (类似:管道.MVC过滤器等)

Demo中的IOC自定义实现

在做练习的时候,小小项目,使用IOC控件觉得麻烦,使用工厂觉得不高大上啊,自己写个简陋的依赖注入IOC吧; 控制反转(IOC)是管理映射依赖的的,是依赖倒置(DIP)的实现方式; 依赖倒置(DIP)是设计原则,控制反转(IOC)是具体实现,依赖注入(DI)是控制反转的具体实现; 解决方案的目录: IOC 有3个类,一个是用来保存依赖关系的实体类(EntityIOC),一个是保存依赖关系的类(InterviewsDependencyResolver),一个是外部调用类(InterviewsIOC)

Android 设计模式 示例集合 以及IOC注解事例 Demo

记得前面一篇篇的写了 Android观察者设计模式demo 策略模式 工厂模式 原型模式 适配器模式 组合模式 以及IOC 注解UI控件demo 集合下事例,把demo上传下. http://download.csdn.net/detail/xufeifandj/8247343

Spring之IOC/DI(反转控制/依赖注入)_入门Demo

软件152 刘安民 在平时的java应用开发中,我们要实现某一个功能或者说是完成某个业务逻辑时至少需要两个或以上的对象来协作完成,在没有使用Spring的时候,每个对象在需要使用他的合作对象时,自己均要使用像new object() 这样的语法来将合作对象创建出来,这个合作对象是由自己主动创建出来的,创建合作对象的主动权在自己手上,自己需要哪个合作对象,就主动去创建,创建合作对象的主动权和创建时机是由自己把控的,而这样就会使得对象间的耦合度高了,A对象需要使用合作对象B来共同完成一件事,A要使用

IOC：AutoFac使用demo

使用autofac 实现依赖注入 1.引用 autofac.dll 和 autofac.configuration.dll 2.新增接口 IDAL using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace AutoFacTest { public interface IDAL { void select(

Spring IOC的简单实现（附demo）

简单的说,Spring就是通过工厂+反射将我们的bean放到它的容器中的,当我们想用某个bean的时候,只需要调用getBean("beanID")方法即可. 原理简单说明: Spring容器的原理,其实就是通过解析xml文件,通过反射创建出我们所需要的bean,再将这些bean挨个放到集合中,然后对外提供一个getBean()方法,以便我们获得这bean. 下面我们来简单实现一个demo beans.xml <?xml version="1.0" encod

【spring】1.spring ioc原理和demo

我们先做一个简单的spring例子. 面向接口编程,我们先来定接口 IHelloWorld package com.services; public interface IHelloWorld { public void sayHello(); } 写一个实现类,并且声明一个String属性,提供set方法注入 package com.services.impl; import com.services.IHelloWorld; public class HelloWorld implement

struts中调用servlet的两种方法——IcC方式和非IoC方式的代码demo

1 package com.java1234.action;//所在的包 2 3 import java.sql.Connection;//数据库连接的类 4 import java.util.ArrayList;//ArrayList和List是在private List<DataDic> dataDicList=new 5 6 ArrayList<DataDic>();中用到 7 import java.util.List;//ArrayList和List是在private L