Spring个人总结

IOC创建对象

package com.spring.pojo;

public class User {
    private String name;

    public User() {
            System.out.println("User的无参构造方法");
    }
//有参构造会覆盖调无参构造,需单独创建无参方法
    public User(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

无参对象

    <bean class="com.spring.pojo.User" id="user">
           <property name="name" value="Java"></property>
    </bean>

有参对象

//方法一:
    <bean class="com.spring.pojo.User" id="user">
          <constructor-arg name="name" value="java"></constructor-arg>
    </bean> 
//方法二:
//user类中
    public User(String name0, String name1) {
        System.out.println(name0);
        System.out.println(name1);
    }

//beans.xml中,index为第几个参数
<bean class="com.spring.pojo.User" id="user">
  <constructor-arg index="0" value="index0"/>
        <constructor-arg index="1" value="index1"/>
</bean>      

Instantiating a Container

        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //默认调用了无参构造,此时会显示无参构造方法内容
        //含有有参构造,则显示有参构造内容
        User user = (User) context.getBean("user");
        User user2 = (User) context.getBean("user");
        //user==user2为true
        System.out.println(user==user2);
         //在配置文件加载的时候,容器中管理的对象就已经开始初始化了,即创建beans.xml中的<bean/>时
        //若此时beans.xml中含有<bean class="com.spring.pojo.Users" id="users"/>且为无参构造,
       //即便仅存在User user = (User) context.getBean("user");也会显示users的无参构造内容

依赖注入

构造器注入

Set方式注入

• 依赖注入:Set注入
  • 依赖:bean对象的创建依赖于容器
  • 注入:bean对象中的所有属性,由容器来注入

自动装配

xml中自动装配

<bean id="cat" class="com.spring.pojo.Cat"></bean>
<bean id="dog" class="com.spring.pojo.Dog"></bean>
<bean id="people" class="com.spring.pojo.People" autowire="byName"/>

注解自动装配

<context:annotation-config/>//xml中,开启注解支持
@Autowired//自动匹配,名称可以不完全一致,但是必须相关,类中可以取消Set方法
@Qualifier(value = "dog")//可以指定Id

@Autowired @Resource @Qualifier的区别

@Autowired 根据类型注入， 必须有这个对象存在
      如果 @Autowired不能唯一装配上属性,则通过@Qualifie("dog") 
    
@Resource 默认根据名字注入，其次按照类型搜索

注解开发

//xml中
    <context:component-scan base-package="com.spring.pojo"/>
    <context:annotation-config/>

1、@controller：   controller控制器层（注入服务）
2、@service ：      service服务层（注入dao）
3、@repository ：  dao持久层（实现dao访问）
//@Component等价于<bean id="user" class="com.spring.pojo.User"/>
4、@component：  标注一个类为Spring容器的Bean，（把普通pojo实例化到spring容器中，相当于配置文件中的<bean id="" class=""/>）

建议:

• xml用来管理bean
• 注解只负责完成属性的注入

代理模式

静态代理

• 真实角色:被代理的角色
• 抽象角色:接口或者抽象类
• 客户
• 代理角色:代理真实角色,可以添加附属操作

动态代理

• 基于接口
• 基于动态代理

抽象类

package com.spring.demo04;

public interface UserService {
    public void add();

    public void delete();

    public void update();

    public void query();
}

真实角色

package com.spring.demo04;

public class UserServiceImpl implements UserService {
    private UserService userService;

    public UserService getUserService() {
        return userService;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public UserServiceImpl(UserService userService) {
        this.userService = userService;
    }

    public UserServiceImpl() {
    }

    @Override
    public void add() {
        System.out.println("增加");
    }

    @Override
    public void delete() {
        System.out.println("删除");

    }

    @Override
    public void update() {
        System.out.println("修改");

    }

    @Override
    public void query() {
        System.out.println("查询");

    }
}

静态代理时的代理角色

使用动态代理后不需要,直接在通过InvocationHandler造一个

package com.spring.demo04;


public class UserServiceProxy implements UserService {
    UserService userService = new UserServiceImpl();

    public UserService getUserService() {
        return userService;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public UserServiceProxy(UserService userService) {
        this.userService = userService;
    }

    public UserServiceProxy() {

    }

    @Override
    public void add() {
        log("add");
        userService.add();
    }

    @Override
    public void delete() {
        log("delete");
        userService.delete();
    }

    @Override
    public void update() {
        log("update");
        userService.update();
    }

    @Override
    public void query() {
        log("query");
        userService.query();
    }

    public void log(String msg) {
        System.out.println(msg);
    }
}

动态代理工具类

package com.spring.demo04;

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

public class ProxyInvocationHandle implements InvocationHandler {
    private Object object;

    public void setObject(Object object) {
        this.object = object;
    }

    public Object gerProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), object.getClass().getInterfaces(), this);

    }

    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        //反射得到代理方法
        System.out.println(method.getName());
        //附属方法
        log();
        //反射得到接口的所有方法,任意调用
        Object invoke = method.invoke(object, objects);
        return invoke;
    }
    public void log() {
        System.out.println("动态代理");
    }
}

运行结果

add
动态代理
add
增加
============
add
动态代理
增加