Java EE 核心框架之 Spring

最新推荐文章于 2022-09-03 15:15:15 发布

鹏程万li

最新推荐文章于 2022-09-03 15:15:15 发布

阅读量1.4k

点赞数

分类专栏： Spring 文章标签： Spring

Spring 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

Java EE 核心框架之 Spring

2011-01-17 22:45:02| 分类： Spring | 标签：spring 环境配置 ioc |字号订阅

Spring 是到目前为止集成功能最强大的框架，它可以继承各种表现层框架（Struts1、Struts2）、持久层框架（Hibernate、Ibatis）等，这都得益于Spring作为IoC容器的特性。除此之外，Spring还提供了类似Struts的MVC开发功能。

Spring 的作用：

① 作为IoC容器。

② 作为MVC框架。

Spring 下载

官方下载：http://www.springsource.org/download

下载文件：spring-framework-3.0.5.RELEASE-with-docs.zip

Spring 环境配置

① 添加JAR包：把lib\目录中的所有 *.jar 文件复制到项目的WebContent\WEB-INF\lib\目录下。

② 添加spring.tld标签库文件：projects\org.springframework.web.servlet\src\main\resources\META-INF\ 目录中的spring.tld 复制到项目的WebContent\WEB-INF\ 目录下。

③ 添加commons-logging.jar 和 log4j-1.2.12.jar 到项目的WebContent\WEB-INF\lib\目录下。添加log4j.properties 文件到项目的src\ 目录下。

④ 添加 applicationContext.xml：projects\org.springframework.context\src\test\java\org\springframework\jmx\ 目录下的 applicationContext.xml 复制到WebContent\WEB-INF\ 目录下。然后再上面进行修改，达到自己的要求。

Spring 用作IoC容器

spring 是一个轻量级的控制反转和面向切面的容器框架。在实际的开发应用中，我们需要避免和降低对象间的依赖关系，即降低耦合度。

IoC(Inversion of Constrol) 控制反转，就是用容器来控制业务对象之间的依赖关系，而非传统方式中用代码来直接操控。控制反转的本质是控制权由应用代码中转到了外部容器，控制权的转移即是所谓的反转。控制权的转移带来的好处就是降低了业务对象之间的依赖程度，即实现了解耦。

IoC的实现策略

① 依赖查找：容器中的受控对象通过容器中的API来查找自己所依赖的资源和协作对象。这种方式虽然降低了对象间的依赖，但同时也是用到了容器中的API，导致我们无法在容器外是用和测试对象。

② 依赖注入（又称DI，Dependency Injection）：对象只提供普通的方法，让容器去决定依赖关系，容器负责组件的装配，它把符合依赖关系的对象通过属性（JavaBean 中的getter 和 setter）或构造函数传递给需要的对象。通过属性注入依赖关系的做法叫设值注入（Setter Injection）；通过构造函数注入依赖关系的方法叫构造注入（Constructor Injection）。

依赖注入的好处有：

① 查询依赖操作和应用代码分离。

② 受控对象不会是用到容器特定的API，这样我们的对象可以搬出容器单独使用。

IoC 模式是解决调用者和被调用者之间的一种关系，在UML中用依赖（Dependency）表示。

软件设计方法及设计模式的发展，共产生了3中类调用的方法：
⑴ 自己创建（new）：自己创建被调用实例对象

⑵ 工厂模式（get）：从工厂获得被调用者实例对象

⑶ 外部注入（set）：被调用者的实例对象是被别处送进来的

第三种方式完全抛开了依赖关系的枷锁，可以自由地由外部注入，这就是IoC，将对象的创建和获取提到外部，由外部容器提供需要的组件。

注：我们通常用接口的方式定义被调用者， 面向抽象和 面向接口编程时 面向对象编程的核心。

利用Java反射机制实现IoC容器

IoC 最基本的java技术就是“反射”编程。反射就是根据给出的类名（字符串）来生成对象。

Java 反射机制主要提供了一下功能：

● 判断任意一个对象所属的类

● 构造任意一个类的对象

● 判断任意一个类所具有的成员变量和方法

● 调用任意一个对象的方法

● 生成动态代理

在JDK中，主要由一下类来实现Java 反射机制，这些类都位于java.lang.reflection包中

● Class 类：代表一个类

● Field 类：代表类的成员变量

● Method 类：代表类的方法

● Constructor 类：代表类的构造方法

● Array 类：动态创建数组，以及访问数组元素的静态方法。

Class<?>cls = Class.forName(" com.demo.hibernate.beans.Worklog");
Class<?>cls = com.demo.hibernate.beans.Worklog. class;

   Class<?>cls = this/Object.getClass();
   String classname = cls.getName(); //获得包名+类名
   Object obj = cls.newInstance();
   Worklog worklog = (Worklog)cls.newInstance(); //实例化
   Worklog worklog = new Worklog();
   Class<?>cls = worklog.getClass(); //通过实例化对象获得类。

   Class[] paramtypes = new Class[1];
   paramtypes[0] = Integer.class;
   Constructor<?>constructor = cls.getConstructor(paramtypes);//调用有参构造函数(Worklog.class中有一个Integer参数的构造器)
   Worklog worklog2 = (Worklog)constructor.newInstance(10);//实例化一个有参的构造构造器

   Constructor<?>constructor = cls.getConstructor();//调用默认构造函数
   Worklog worklog = (Worklog)constructor.newInstance();//实例化一个默认的构造构造器

   Class<?>[] paramTypes = new Class[]{String.class,Integer.class};
   Mthod method = cls.getDeclaredMethod("methodName",paramTypes); //获得方法名为“methodName” 的方法
   Mthod method = cls.getMethod("methodName",paramTypes); //获得声明为public，方法名为“methodName” 的方法
   Object[] params = new Object[]{"XXX",100}
   Object result = method.invoke(object,params); //调用方法

   Method[] methods = cls.getDeclaredMethods(); //获得类中所有的方法
   Method[] methods = cls.getMethods(); 获得类中所有public 的方法
   for(Method m : methods){
             System.out.println("方法："+m);
             System.out.println("方法名："+m.getName());
             System.out.println("方法修饰符："+m.getModifiers());
   }

Field field = cls.getDeclaredField("fieldName"); //获得类中变量名为“fieldName”的变量
Field field = cls.getField("fieldName"); //获得类中声明为public，变量名为“fieldName”的变量

   field.set(object,fieldValue) //给变量赋值
   field.get(object) //获得变量的值
    注：如果变量“fieldName”声明为“private”，将会抛出异常。

   Field[] fields = cls.getDeclaredFields(); //获得类中所有的变量
   Field[] fields = cls.getFields();   获得类中所有public的变量
   for(Field f : fields){
             System.out.println("变量："+f);
            System.out.println("变量名："+f.getName());
             System.out.println("变量修饰符："+f.getModifiers());
   }
   Constructor<?>[] constructors = cls.getDeclaredConstructors(); //获得类中所有的构造函数
   Constructor<?>[] constructors = cls.getConstructors();//获得类中所有public的构造函数
   for(Constructor<?> c : constructors){
            System.out.println("构造器："+c);
            System.out.println("构造器名："+c.getName());
            System.out.println("构造器修饰符："+c.getModifiers());
   }