Spring01

 基于xml方式注入属性
1，DI 依赖注入，就是注入属性

原始方式设置属性：

public class Book {
    private String bname;

    public String getBname() {
        return bname;
    }

    public void setBname(String bname) {
        this.bname = bname;
    }

    public static void main(String[] args) {
        Book book = new Book();
        book.setBname("java语言程序设计");
    }
}

在xml配置文件中注入属性：

 <bean id="book" class="spring01.Book">
        <property name="bname" value="java语言程序设计"></property>
    </bean>

p名称空间注入:
1,使用p名称空间注入,可以简化基于xml配置方式
第一步 :
添加p名称空间在配置

xmlns:p="http://www.springframework.org/schema/p"

第二步:

简化之前设置属性:

<bean id="book" class="spring01.Book">
    <property name="bname" value="java语言程序设计"></property>
</bean>
简化之后设置属性:
<bean id="book" class="spring01.Book" p:bname="c语言">
</bean>

//设置空值
<bean id="book" class="spring01.Book">
    <property name="bname" >
        <null/>
    </property>
</bean>

    //含有特殊符号的
    <bean id="book" class="spring01.Book">
        //错误写法
<!--        <property name="bname"  value="<<南京>>"></property>-->
        // 使用CDATA 正确写法 或者使用转义
        <property name="bname">
            <value> <![CDATA[<<南京>>]]>   </value>
        </property>
    </bean>

 注入属性-内部bean和级联赋值
1,一对多的关系 部门和员工

2,在实体类之间表示一对多的关系

public class Emp {
    public String ename;
    private Dept dept;

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }
}
-----------------------------------------------
public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }
}

 

什么是Aop?
1,面向切面编程,利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,
提到程序的可重用行,同时提高了开发的效率

通俗描述就是,不通过修改源代码的方式,在主干功能里添加新的功能 

---

AOP底层使用动态代理
有两种情况动态代理
1,有接口,使用jdk动态代理
创建接口实现类代理对象,增强类的方法 

 2,没有接口 使用CGLIB动态代理

---

创建子类的代理对象,增强类的方法

AOP (JDK动态代理)
使用jdk动态代理,使用Proxy类里的方法创建代理对象
调用newProxyInstance方法,静态方法
方法里有三个参数
1,类加载器 classLoader 
2,增强方法所在的类,这个类实现的接口,可以有多个类
3,实现这个接口,InvocationHandler,创建代理对象,写增强的方法

 

public interface Dao {
    public int add(int a,int b);
}
==============================
public class DaoImpl implements Dao{
    public int add(int a,int b){
        System.out.println("add方法正在执行");
        return (a+b);
    }
}
==============================
package test1;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class DaoProxy {
    public static void main(String[] args) {
        Class [] interfaces = {Dao.class};
        DaoImpl dao = new DaoImpl();
        // 1 类加载器     2 扩展方法的类实现的接口   3 Invocatonhandler 的实现类
        Dao dao1 = (Dao) Proxy.newProxyInstance(DaoProxy.class.getClassLoader(),interfaces,new invo(dao));
        int add = dao1.add(1, 2);
        System.out.println(add);
    }
}
//3 Invocatonhandler 的实现类 的要求
/*
1,  构造方法传入扩展方法的类
2,  返回invoke方法的返回值
 */
class invo implements InvocationHandler {
    private Object obj;
    public invo(Object obj) {
        this.obj=obj;
    }

    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        System.out.println("大哥郊县");
        System.out.println(method.getName());

        Object invoke = method.invoke(obj, objects);

        System.out.println("一切都结束了");
        return invoke;
    }
}

AOP 的术语
1, 连接点
类里面的哪些方法可以被增强,这些方法成为连接点
2,切入点
实际被真正增强的方法就成为切入点
3,通知(增强)
实际增强的逻辑部分称为通知(增强)
通知有多种类型
*前置通知
*后置通知
*环绕通知
*异常通知
*最终通知
4,切面
是动作,把通知应用到切入点的过程