Spring中IOC的Annotation实现

Spring中IOC的Annotation实现:

此处特别注意每个类中注释的注解及相关文字说明,可以更好的理解Spring中IOC的Annotation实现!

首先beans.xml中需要引入 context 的schema:

[html] view
plain
copyprint?

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  5. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">

在XML中配置Spring对Annotation的相关配置:

[html] view
plain
copyprint?

  1. <!-- 打开Spring的Annotation的支持 -->
  2. <context:annotation-config />
  3. <!-- 设定Spring去哪些包中找Annotation -->
  4. <context:component-scan base-package="com.spring" />

完整的XML配置:

[html] view
plain
copyprint?

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  5. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
  6. <!-- 打开Spring的Annotation的支持 -->
  7. <context:annotation-config />
  8. <!-- 设定Spring去哪些包中找Annotation -->
  9. <context:component-scan base-package="com.spring" />
  10. </beans>

User实体类:

[java] view
plain
copyprint?

  1. package com.spring.model;
  2. public class User {
  3. public User() {
  4. super();
  5. }
  6. private int id;
  7. private String username;
  8. public int getId() {
  9. return id;
  10. }
  11. public void setId(int id) {
  12. this.id = id;
  13. }
  14. public String getUsername() {
  15. return username;
  16. }
  17. public void setUsername(String username) {
  18. this.username = username;
  19. }
  20. @Override
  21. public String toString() {
  22. return "User [id=" + id + ", username=" + username + "]";
  23. }
  24. public User(int id, String username) {
  25. super();
  26. this.id = id;
  27. this.username = username;
  28. }
  29. }

IUserDao接口:

[java] view
plain
copyprint?

  1. package com.spring.dao;
  2. import com.spring.model.User;
  3. public interface IUserDao {
  4. public void add(User user);
  5. public void delete(int id);
  6. public User load(int id);
  7. }

UserDao类:

[java] view
plain
copyprint?

  1. package com.spring.dao;
  2. import org.springframework.stereotype.Component;
  3. import org.springframework.stereotype.Repository;
  4. import com.spring.model.User;
  5. //等于完成了<bean id="userDao" class="com.spring.dao.UserDao"/>
  6. //@Component("userDao") //@Component公共的创建bean的Annotation
  7. @Repository("userDao")  //@Repository表示一般用于Dao的注入
  8. public class UserDao implements IUserDao {
  9. @Override
  10. public void delete(int id) {
  11. System.out.println("删除了"+id);
  12. }
  13. @Override
  14. public User load(int id) {
  15. System.out.println("load了User");
  16. return null;
  17. }
  18. @Override
  19. public void add(User user) {
  20. System.out.println("添加了"+user);
  21. }
  22. }

IUserService接口:

[java] view
plain
copyprint?

  1. package com.spring.service;
  2. import com.spring.model.User;
  3. public interface IUserService {
  4. public void add(User user);
  5. public void delete(int id);
  6. public User load(int id);
  7. }

UserService类:

[java] view
plain
copyprint?

  1. package com.spring.service;
  2. import javax.annotation.Resource;
  3. import org.springframework.stereotype.Component;
  4. import org.springframework.stereotype.Service;
  5. import com.spring.dao.IUserDao;
  6. import com.spring.model.User;
  7. //@Component(value="userService")
  8. @Service("userService")     //业务层一般用@Service注入
  9. public class UserService implements IUserService {
  10. private IUserDao userDao;
  11. public IUserDao getUserDao() {
  12. return userDao;
  13. }
  14. //默认通过名称注入,在JSR330中提供了@Inject来注入
  15. @Resource
  16. public void setUserDao(IUserDao userDao) {
  17. this.userDao = userDao;
  18. }
  19. @Override
  20. public void add(User user) {
  21. userDao.add(user);
  22. }
  23. @Override
  24. public void delete(int id) {
  25. userDao.delete(id);
  26. }
  27. @Override
  28. public User load(int id) {
  29. return userDao.load(id);
  30. }
  31. }

UserAction类:

[java] view
plain
copyprint?

  1. package com.spring.action;
  2. import javax.annotation.Resource;
  3. import org.springframework.context.annotation.Scope;
  4. import org.springframework.stereotype.Component;
  5. import org.springframework.stereotype.Controller;
  6. import com.spring.model.User;
  7. import com.spring.service.IUserService;
  8. //@Component("userAction")
  9. @Controller("userAction")   //MVC的控制层一般使用@Controller
  10. @Scope("prototype")     //设置多例
  11. public class UserAction {
  12. private User user;
  13. private IUserService userService;
  14. private int id;
  15. public User getUser() {
  16. return user;
  17. }
  18. public void setUser(User user) {
  19. this.user = user;
  20. }
  21. public IUserService getUserService() {
  22. return userService;
  23. }
  24. @Resource
  25. public void setUserService(IUserService userService) {
  26. this.userService = userService;
  27. }
  28. public int getId() {
  29. return id;
  30. }
  31. public void setId(int id) {
  32. this.id = id;
  33. }
  34. public void add(){
  35. userService.add(user);
  36. }
  37. public void delete(){
  38. userService.delete(id);
  39. }
  40. public void load(){
  41. userService.load(id);
  42. }
  43. }

测试类:

[java] view
plain
copyprint?

  1. package com.spring.test;
  2. import org.junit.Test;
  3. import org.springframework.beans.factory.BeanFactory;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  5. import com.spring.action.UserAction;
  6. import com.spring.model.User;
  7. public class TestSpring {
  8. //创建Spring工厂
  9. private BeanFactory beanFactory=new ClassPathXmlApplicationContext("beans.xml");
  10. @Test
  11. public void testUser(){
  12. UserAction ua=beanFactory.getBean("userAction",UserAction.class);
  13. User user=new User(1,"我叫spring");
  14. ua.setUser(user);
  15. ua.add();
  16. //单例的时候添加相同的内容,多例添加为null
  17. UserAction ua1=beanFactory.getBean("userAction",UserAction.class);
  18. ua1.add();
  19. }
  20. }

运行结果及项目结果图:

时间: 2024-10-05 17:49:55

Spring中IOC的Annotation实现的相关文章

Spring中IoC的入门实例

Spring中IoC的入门实例 Spring的模块化是很强的,各个功能模块都是独立的,我们可以选择的使用.这一章先从Spring的IoC开始.所谓IoC就是一个用XML来定义生成对象的模式,我们看看如果来使用的. 数据模型 1.如下图所示有三个类,Human(人类)是接口,Chinese(中国人)是一个子类,American(美国人)是另外一个子类. 源代码如下: package cn.com.chengang.spring;public interface Human {void eat();

对Spring中IOC和DI的理解

前几篇讲了Spring中IOC和DI的用法,本篇应该放到三篇之前,但一直没有想到好的讲解方式,后参考https://blog.csdn.net/luoyepiaoxue2014/article/details/72426666博客,对其中涉及到的进行了简单的总结. 在学习Spring的过程中,总会涉及到两个概念---IOC和DI,即控制反转和依赖注入,而对这两个概念的理解也总是含糊不清的,下面就对自己的理解进行总结. 首先是IOC,即控制反转,需要理解的是:怎么控制?谁控制了什么?怎么反转?既然

Spring 中 IoC 容器简介

IoC 是一种通过描述来生成或者获取对象的技术,可以说 Spring 是一种基于 IoC 容器编程的框架 在一个系统中可以生成各种对象,并且这些对象都需要进行管理.为了描述这些对象关系,我们需要一个容器.在 Spring 中把每一个需要管理的对象称为 Spring Bean ,而管理这些 Bean 的容器就被称为 Spring IoC 容器. IoC 容器需要具备两个基本的功能: 通过描述管理 Bean ,包括发布和获取 Bean 通过描述完成 Bean 之间的依赖关系 介绍 Spring Io

spring中IOC的简单使用

spring的ioc主要就是依赖注入,有基于构造器的依赖注入还有通过设值注入,这里我只简单的实现设值注入的方法,通过spring的依赖管理,我们可以很方便的了解各层之间的依赖关系,降低了各层之间的耦合,我们可以不用过多的去关注对象的管理和创建,我们只需要去bean工厂申请即可,这样我们更多的注意力就可以放到真正的代码实现,而不用去关心代码的创建和销毁.,接下来时简单的设值注入. 我们先简单的去创建一个学生类和老师类 public class Student { public void outhi

《Java从入门到放弃》入门篇:spring中IOC的注入姿势

IOC到底是个什么东东呢?控制反转(Inversion of Control,英文缩写为IoC),其实就是这个东东. 你随便百度一下就会得到比较书面的解释:通过引入实现了IoC模式的IoC容器,即可由IoC容器来管理对象的生命周期.依赖关系等,从而使得应用程序的配置和依赖性规范与实际的应用程序代码分开.其中一个特点就是通过文本的配置文件进行应用程序组件间相互关系的配置,而不用重新修改并编译具体的代码. 说了这么多,通过一个例子就能很好的来理解.以前小王要找对象,要么云茫茫人海中进行匹配(通过 小

Spring中IOC和AOP的详细解释

我们是在使用Spring框架的过程中,其实就是为了使用IOC,依赖注入,和AOP,面向切面编程,这两个是Spring的灵魂. 主要用到的设计模式有工厂模式和代理模式. IOC就是典型的工厂模式,通过sessionfactory去注入实例. AOP就是典型的代理模式的体现. 代理模式是常用的java设计模式,他的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息.过滤消息.把消息转发给委托类,以及事后处理消息等.代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对

对Spring中IOC和AOP的理解

IOC:控制反转也叫依赖注入.利用了工厂模式. 为了方便理解,分解成每条以便记忆.  1.将对象交给容器管理,你只需要在spring配置文件总配置相应的bean,以及设置相关的属性,让spring容器来生成类的实例对象以及管理对象.2.在spring容器启动的时候,spring会把你在配置文件中配置的bean都初始化好,3.在你需要调用的时候,就把它已经初始化好的那些bean分配给你需要调用这些bean的类(假设这个类名是A),分配的方法就是调用A的setter方法来注入,而不需要你在A里面ne

Spring中ioc的实现原理

学习过Spring框架的人一定都会听过Spring的IoC(控制反转) .DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC .DI这两个概念是模糊不清的,是很难理解的,今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring Ioc的理解. 一.分享Iteye的开涛对Ioc的精彩讲解 首先要分享的是Iteye的开涛这位技术牛人对Spring框架的IOC的理解,写得非常通俗易懂,以下内容全部来自原文,原文地址:http://jinniansh

JavaWeb_(Spring框架)Spring中IoC与DI概念入门

Spring是于2003 年兴起的一个轻量级的Java 开源框架,它由Rod Johnson创建.传统J2EE应用的开发效率低,Spring作为开源的中间件,提供J2EE应用的各层的解决方案,Spring贯穿了表现层.业务层及持久层,而不是仅仅专注于某一层的方案.可以说Spring是企业应用开发的“一站式(full-stack)”选择.然而,Spring并不想取代那些已有的框架,而是与它们无缝地整合. 简单来说,Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架. Spri