下面还有静态代理和动态代理

1.构造注入

lib包:

在entity包下新建一个实体类User

代码:

  1. package cn.happy.entity;
  2.  
  3. public class User {
  4. private Integer id;
  5. private String name;
  6. private String age;
  7. private String eamil;
  8.  
  9. public User(Integer id, String name, String age, String eamil) {
  10. this.id = id;
  11. this.name = name;
  12. this.age = age;
  13. this.eamil = eamil;
  14. }
  15. public User(String name, String age, String eamil) {
  16. super();
  17. this.name = name;
  18. this.age = age;
  19. this.eamil = eamil;
  20. }
  21. public User() {
  22. }
  23. public User(String name, String age) {
  24. this.name = name;
  25. this.age = age;
  26. }
  27.  
  28. public Integer getId() {
  29. return id;
  30. }
  31. public void setId(Integer id) {
  32. this.id = id;
  33. }
  34. public String getName() {
  35. return name;
  36. }
  37. public void setName(String name) {
  38. this.name = name;
  39. }
  40. public String getAge() {
  41. return age;
  42. }
  43. public void setAge(String age) {
  44. this.age = age;
  45. }
  46. public String getEamil() {
  47. return eamil;
  48. }
  49. public void setEamil(String eamil) {
  50. this.eamil = eamil;
  51. }
  52. @Override
  53. public String toString() {
  54. return "User [id=" + id + ", name=" + name + ", age=" + age
  55. + ", eamil=" + eamil + "]";
  56. }
  57.  
  58. }

User

在applicationContext.xml里面写

约束-头:

别忘记带这个不然会报错的applicationContext.xml里面!

  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"
  4. xmlns:aop="http://www.springframework.org/schema/aop"
  5. xmlns:p="http://www.springframework.org/schema/p"
  6. xsi:schemaLocation="
  7. http://www.springframework.org/schema/beans
  8. http://www.springframework.org/schema/beans/spring-beans.xsd
  9. http://www.springframework.org/schema/aop
  10. http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
  11. ">

applicationContext.xml

代码:

  1. <bean id="user1" class="cn.happy.entity.User">
  2. <constructor-arg index="0" type="java.lang.String" value="LXL"></constructor-arg>
  3. <constructor-arg index="1" type="java.lang.String" value="12"></constructor-arg>
  4. </bean>

applicationContext.xml

测试类:Text

代码:

  1. public class Text {
  2. @Test
  3. public void inner(){
  4. gouinner();
  5. }
  6. //p命名空间注入
  7. static void gouinner(){
  8. ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
  9. User user=(User)context.getBean("user1");
  10. System.out.println(user);
  11. }

text

结果:

2.P命名空间注入

这个实体类和上面的一样就演示了

在applicationContext.xml里面写

代码:

  1. <!-- p命名空间注入 -->
  2. <bean id="user2" class="cn.happy.entity.User" p:name="你的肉" p:age="1" p:eamil="niderou@123.com"/>

applicationContext.xml

测试类Text:

代码:

  1. @Test
  2. public void inner(){
  3. Pinner();
  4. }
  5. //构造注入
  6. static void Pinner(){
  7. ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
  8. User user=(User)context.getBean("user2");
  9. System.out.println(user);
  10. }

text

结果:

3.注入集合的属性

List

实体类Jihe:

代码:

  1. package cn.happy.entity;
  2.  
  3. import java.util.List;
  4. import java.util.Map;
  5. import java.util.Properties;
  6. import java.util.Set;
  7.  
  8. public class Jihe {
  9. private List<String> list;
  10.  
  11. private Set<String> set;
  12.  
  13. private Map<String,String> map;
  14.  
  15. private Properties props;
  16.  
  17. public Properties getProps() {
  18. return props;
  19. }
  20.  
  21. public void setProps(Properties props) {
  22. this.props = props;
  23. }
  24.  
  25. public Map<String, String> getMap() {
  26. return map;
  27. }
  28.  
  29. public void setMap(Map<String, String> map) {
  30. this.map = map;
  31. }
  32.  
  33. public Set<String> getSet() {
  34. return set;
  35. }
  36.  
  37. public void setSet(Set<String> set) {
  38. this.set = set;
  39. }
  40.  
  41. public List<String> getList() {
  42. return list;
  43. }
  44.  
  45. public void setList(List<String> list) {
  46. this.list = list;
  47. }
  48.  
  49. }

Jihe

在applicationContext.xml里面写

代码:

  1. <!-- list -->
  2. <bean id="list1" class="cn.happy.entity.Jihe">
  3. <property name="list">
  4. <list>
  5. <value>你的肉</value>
  6. <value>你的菜</value>
  7. </list>
  8. </property>
  9. </bean>

applicationContext.xml

测试类Text:

代码:

  1. public class Text {
  2. @Test
  3. public void inner(){
  4. listinner();
  5. }
  6. //list
  7. static void listinner(){
  8. ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
  9. Jihe jihe=(Jihe)context.getBean("list1");
  10. System.out.println(jihe.getList());
  11. }

Text

结果:

Set:

实体类和List的实体类一样

在applicationContext.xml里面写

代码:

  1. <!-- Set -->
  2. <bean id="set1" class="cn.happy.entity.Jihe">
  3. <property name="set">
  4. <set>
  5. <value>jd</value>
  6. <value>tb</value>
  7. </set>
  8. </property>
  9. </bean>

applicationContext.xml

测试类Text:

代码:

  1. @Test
  2. public void inner(){
  3. setinner();
  4. }
  5.  
  6. //set
  7. static void setinner(){
  8. ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
  9. Jihe jihe=(Jihe)context.getBean("set1");
  10. System.out.println(jihe.getSet());
  11. }

Text

结果:

Map

实体类和List的也一样

在applicationContext.xml里面写

代码:

  1. <!-- map -->
  2. <bean id="map1" class="cn.happy.entity.Jihe">
  3. <property name="map">
  4. <map>
  5. <entry key="football" value="足球"></entry>
  6. <entry key="basketball" value="篮球"></entry>
  7. </map>
  8. </property>
  9. </bean>

applicationContext.xml

测试类Text:

代码:

  1. public class Text {
  2. @Test
  3. public void inner(){
  4. mapinner();
  5. }
  6.  
  7. //map
  8. static void mapinner(){
  9. ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
  10. Jihe jihe=(Jihe)context.getBean("map1");
  11. System.out.println(jihe.getMap());
  12. }

Text

结果:

properties

实体类和List的也一样

在applicationContext.xml里面写

代码:

  1. <!-- properties -->
  2.  
  3. <bean id="props1" class="cn.happy.entity.Jihe">
  4. <property name="props">
  5. <props>
  6. <prop key="ndr">你的肉</prop>
  7. <prop key="ndc">你的菜</prop>
  8. </props>
  9. </property>
  10. </bean>

applicationContext.xml

测试类Text:

代码:

  1. public class Text {
  2. @Test
  3. public void inner(){
  4. propinner();
  5. }
  6.  
  7. //properties
  8. static void propinner(){
  9. ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
  10. Jihe jihe=(Jihe)context.getBean("props1");
  11. System.out.println(jihe.getProps());
  12. }

Text

结果:

-------------------------------------------------------------------------------------------------------------------

接下来是!!!

静态代理

代理模式 (静态代理)
接口 :方法
---->RealClass:接口
---->ProxyClass:接口
private 接口类型 接口变量;
public void 同名方法(){
syso("增强处理");
接口变量.同名方法();
}

列表

创建一个接口Subject:

代码:

  1. package cn.happy.proxy;
  2.  
  3. public interface Subject {
  4. String quest();
  5. }

Subject

在创建一个SubjectText类继承Subject:

代码:

  1. package cn.happy.proxy;
  2.  
  3. public class SubjectText implements Subject {
  4.  
  5. public String quest() {
  6. return "增强";
  7. }
  8.  
  9. }

SubjectText

在创建一个代理类ProxySubject同样继承Subject:

代码:

  1. package cn.happy.proxy;
  2.  
  3. public class ProxySubject implements Subject {
  4. private Subject subject;
  5.  
  6. public Subject getSubject() {
  7. return subject;
  8. }
  9.  
  10. public void setSubject(Subject subject) {
  11. this.subject = subject;
  12. }
  13.  
  14. public String quest() {
  15. System.out.println("代理增强");
  16. return subject.quest();
  17. }
  18.  
  19. }

ProxySubject

测试类Text:

代码:

  1. package cn.happy.Text;
  2.  
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  6.  
  7. import org.junit.Test;
  8.  
  9. import cn.happy.proxy.ProxySubject;
  10. import cn.happy.proxy.Subject;
  11. import cn.happy.proxy.SubjectText;
  12.  
  13. public class Text {
  14. @Test
  15. public void inner(){
  16. Subject sub=new SubjectText();//被代理的对象
  17. ProxySubject proxy=new ProxySubject();//代理对象
  18. proxy.setSubject(sub);
  19. String quest = proxy.quest();
  20. System.out.println(quest);
  21. }
  22. }

Text

结果:

动态代理

proxy包里的类和静态代理的一样只是测试类换了

测试类Text:

代码:

  1. package cn.happy.Text;
  2.  
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  6.  
  7. import org.junit.Test;
  8.  
  9. import cn.happy.proxy.ProxySubject;
  10. import cn.happy.proxy.Subject;
  11. import cn.happy.proxy.SubjectText;
  12.  
  13. public class Text {
  14. @Test
  15. public void inner(){
  16.  
  17. final Subject sub=new SubjectText();
  18. Subject proxy=(Subject) Proxy.newProxyInstance(sub.getClass().getClassLoader(), sub.getClass().getInterfaces(), new InvocationHandler() {
  19.  
  20. public Object invoke(Object proxy, Method method, Object[] args)
  21. throws Throwable {
  22. System.out.println("增强代码");
  23. return method.invoke(sub, args);
  24. }
  25. });
  26. proxy.quest();
  27.  
  28. }
  29. }

Text

结果:

IOC和Aop使用的扩展的更多相关文章

  1. Spring的IOC和AOP之深剖

    今天,既然讲到了Spring 的IOC和AOP,我们就必须要知道 Spring主要是两件事: 1.开发Bean:2.配置Bean.对于Spring框架来说,它要做的,就是根据配置文件来创建bean实例 ...

  2. Spring IOC AOP的原理 如果让你自己设计IOC,AOP如何处理(百度)

    百度的面试官问,如果让你自己设计一个IOC,和AOP,如何设计, 我把IOC的过程答出来了,但是明显不对, (1) IOC 利用了反射,自己有个id,classtype,hashmap,所有的功能都在 ...

  3. 沉淀再出发:IoC和AOP的本质

    沉淀再出发:IoC和AOP的本质 一.前言 关于IoC和AOP这两个概念,如果我们没有深入的理解可以说是根本就不理解Spring这个架构的,同样的由Spring演变出来的Spring Boot和Spr ...

  4. Spring框架IOC和AOP介绍

    说明:本文部分内容参考其他优秀博客后结合自己实战例子改编如下 Spring框架是个轻量级的Java EE框架.所谓轻量级,是指不依赖于容器就能运行的.Struts.Hibernate也是轻量级的. 轻 ...

  5. 展开说说,Spring Bean IOC、AOP 循环依赖

    作者:小傅哥 博客:https://bugstack.cn 沉淀.分享.成长,让自己和他人都能有所收获! 一.前言 延迟满足能给你带来什么? 大学有四年时间,但几乎所有人都是临近毕业才发现找一份好工作 ...

  6. spring的IOC和AOP协同工作

    看网络上的spring资料,基本都是在讲解IOC和AOP,但是二者是如何协同工作的,说的很少. 粗略调试了下BeanFactory的创建过程,发现是如图所示的大概过程.其中BeanPostProces ...

  7. spring - ioc和aop

    1.程序中为什么会用到spring的ioc和aop 2.什么是IOC,AOP,以及使用它们的好处,即详细回答了第一个问题 3.原理 关于1: a:我们平常使用对象的时候,一般都是直接使用关键字类new ...

  8. spring的IOC和AOP

     spring的IOC和AOP 1.解释spring的ioc? 几种注入依赖的方式?spring的优点? IOC你就认为他是一个生产和管理bean的容器就行了,原来需要在调用类中new的东西,现在都是 ...

  9. Castle框架中的IOC和AOP机制

    反转控制(IOC)和面向切面编程(AOP)技术作为当前比较流行的技术,其优势已受到广泛关注,但是这两项新技术在实际项目上的应用研究却很落后,而且在.NET平台下实现这两项技术没有形成可以广泛套用的框架 ...

随机推荐

  1. HTML5 十大新特性(九)——Web Storage

    H5的webStorage技术一共提供了两个对象:window.sessionStorage和window.localStorage. 一.window.sessionStorage--会话级存储 存 ...

  2. Student elective system (VF)

    博客插N+文件有些麻烦,索性PDF上传到百度文库 点击获取<数据库系统原理与应用>也有相应的word版本 word版加密密码:(博客链接加密后) 六.附录 数据库设计的基本步骤,按照规范设 ...

  3. 【转】OPENGL基本API概述

    本文信息资源来源于网络,欢迎转载!转载时请保留本文链接(http://www.shopliyang.com.cn/)! OpenGL中的gl库是核心库,glu是实用库,glut是实用工具库. gl是核 ...

  4. 将项目上传到git上,并在测试服务器上运行

    上周我完成了我人生的第一个项目,并将它上传到gitHub上完成了团队合作.下面我将用倒叙的方法记录下,我的这段经历. 星期五,项目完成准备上传gitHub启动测试服务器. 1.git clone 项目 ...

  5. php gettext 注释

    //setlocale(LC_ALL, "en_US.UTF-8"); setlocale(LC_ALL, "zh_CN.UTF-8"); bindtextdo ...

  6. Android开发--apk的生成

    0.前言 此方法为eclipse中生成apk的方法!!!! 1.生成ketstore 在命令提示符中找到java的jdk路径,例如: D:\study software\Java\jdk1.8.0_2 ...

  7. JS学习笔记01

    文章转载pigpigpig4587 的 1.Javascript是区分大小写的语言.也就是说.关键字.变量,函数和所有的标识符都必须采取一致的大小写形式.因为html不严格区分大小写,所以在html中 ...

  8. centos mongodb cluster install 完全版

    分享一则用yum安装的mongodb初始化脚本. install_mongodb.sh会安装mongodb所需的基本环境. 配置副本集的时候会需要辅助文件hosts.conf. 说明:该示例为一主一丛 ...

  9. ldconfig和ldd用法

    一.ldconfig ldconfig是一个动态链接库管理命令,为了让动态链接库为系统所共享,还需运行动态链接库的管理命令--ldconfig. ldconfig 命令的用途,主要是在默认搜寻目录(/ ...

  10. IO 相关配置参数

    INNODB I/O相关配置 记录日志为顺序I/O,刷新日志到数据文件为随机操作.顺序操作性能快于随机IO. innodb_log_file_size innodb_log_files_in_grou ...