zoukankan html css js c++ java

spring IOC简单入门

spring的核心是ioc和aop

先介绍一下IOC（inverse of control控制反转）又叫DI（Dependency injection依赖注入）

个人理解为把对象的控制权由类转移到配置文件中把类所需要的对象通过配置文件注入到类中可以表述不太准确

我们可以模拟spring 的BeanFactory和ClassPathXmlApplicationContext 但是这不重要

package com.ouc.wkp.spring;

public interface BeanFactory {
    public Object getBean(String id);
}

BeanFactory.java

package com.ouc.wkp.spring;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.input.SAXBuilder;

public class ClassPathXmlApplicationContext implements BeanFactory{

    private Map<String, Object> beans=new HashMap<String,Object>();
    
    public ClassPathXmlApplicationContext() throws Exception{
        SAXBuilder sb = new SAXBuilder();

        Document doc = sb.build("src\com\ouc\wkp\test\beans.xml"); // 构造文件对象
        Element root = doc.getRootElement(); // 获取根元素HD
        List<?> list = root.getChildren("bean");// 取名字为bean的所有元素
        for (int i = 0; i < list.size(); i++) {
            Element element = (Element) list.get(i);
            String id = element.getAttributeValue("id");
            String clazz = element.getAttributeValue("class");
            Object o=Class.forName(clazz).newInstance();
            System.out.println(id);
            System.out.println(clazz);
            beans.put(id,o);
            
            for(Element propertyElement:(List<Element>)element.getChildren("property")){
                String name=propertyElement.getAttributeValue("name");
                String bean=propertyElement.getAttributeValue("bean");   //u
                Object beanObject=beans.get(bean);  //UserDAOImpl instance
                String methodName="set" +name.substring(0,1).toUpperCase()+name.substring(1);
                System.out.println("method name="+methodName);
                
                Method m=o.getClass().getMethod(methodName, beanObject.getClass().getInterfaces()[0]);//setUserDAO(UserDAO)
                m.invoke(o, beanObject);
            }
        }
    }
    
    @Override
    public Object getBean(String id) {
        return beans.get(id);
    }

}

ClassPathXmlApplicationContext.java

代码中的路径需要更改

介绍注入的两种方式xml和annotation，先介绍xml方式

项目结构图下面是注入的实例先一个User实体类

package com.ouc.wkp.model;

public class User {
    private String username;
    private String password;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

User.java

一个接口UserDAO

package com.ouc.wkp.dao;

import com.ouc.wkp.model.User;

public interface UserDAO {
    public void save(User user);
}

UserDAO.java

接口实现UserDAOImpl

package com.ouc.wkp.dao.impl;

import java.util.List;
import java.util.Map;
import java.util.Set;

import com.ouc.wkp.dao.UserDAO;
import com.ouc.wkp.model.User;

public class UserDAOImpl implements UserDAO {

    public void save(User user) {
        // Hibernate
        // JDBC
        // XML
        // NetWork
        System.out.println("user saved!");
    }

    private Set<String> sets;
    private List<String> lists;
    private Map<String, String> maps;

    public Set<String> getSets() {
        return sets;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    public List<String> getLists() {
        return lists;
    }

    public void setLists(List<String> lists) {
        this.lists = lists;
    }

    public Map<String, String> getMaps() {
        return maps;
    }

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public UserDAOImpl() {
    }

    @Override
    public String toString() {
        return "sets size:" + sets.size() + "| lists size:" + lists.size()
                + "| maps size:" + maps.size();
    }

}

UserDAOImpl.java

上面代码里面的list set map 和 toString方法是测试通过配置文件给对象里面的属性赋值

然后是UserService

package com.ouc.wkp.service;

import com.ouc.wkp.dao.UserDAO;
import com.ouc.wkp.model.User;


public class UserService {
    private UserDAO userDAO;  
    private UserService(UserDAO userDAO) {
        this.userDAO = userDAO;
    }
    public void init(){
        System.out.println("init");
    }
    public void destroy(){
        System.out.println("destroy");
    }
    public void add(User user) {
        userDAO.save(user);
    }
    public UserDAO getUserDAO() {
        return userDAO;
    }
    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }
}

UserService.java

然后是两个配置文件，命名比较随意

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">
    <!-- default-autowire= -->
    <!-- 在spring中，singleton属性默认是true，只有设定为false，则每次指定别名取得的Bean时都会产生一个新的实例 -->
    <bean id="u" class="com.ouc.wkp.dao.impl.UserDAOImpl" />
    <!-- 自动装配 autowire -->
    <!-- scope 生命范围  singleton单例 prototype每次创建新的对象 -->
    <!-- init-method=""  destory-method=""-->
    <bean id="userservice" class="com.ouc.wkp.service.UserService" scope="prototype" init-method="init"  destroy-method="destroy">
        <!-- 指set方法 注入 -->
<!--         <property name="userDAO" ref="u" /> -->
         <constructor-arg> 
             <ref bean="u" /> 
         </constructor-arg> 
    </bean>
</beans>

beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
           
  <bean id="userDAO" class="com.ouc.wkp.dao.impl.UserDAOImpl">
      <property name="sets">
          <set>
              <value>1</value>
              <value>2</value>
          </set>
      </property>
      <property name="lists">
          <list>
              <value>1</value>
              <value>2</value>
              <value>3</value>
          </list>
      </property>
      <property name="maps">
          <map>
              <entry key="1" value="1"></entry>
              <entry key="2" value="2"></entry>
              <entry key="3" value="3"></entry>
              <entry key="4" value="4"></entry>
          </map>
      </property>
  </bean>

  <bean id="userService" class="com.ouc.wkp.service.UserService">
  <!-- 
      <property name="userDAO">
          <ref bean="userDAO"/>
      </property>
       -->
       <constructor-arg>
           <ref bean="userDAO"/>
       </constructor-arg>
  </bean>


</beans>

beans1.xml

我们看一下配置文件

<beans></beans>是最外层标签

第一层子元素是<bean></bean>标签代表一个类实例化时的对象

属性id用于唯一标识这个对象。

class用于指定这个类文件的位置，输入完毕后按ctrl，如果生成可以跳转的链接说明输入正确。

scope代表生命范围，默认是singleton即单例模式，如果设置为prototype则每次实例化都生成一个新的对象。

init-method="init" destroy-method="destroy"标识对象初始化和销毁时分别调用init() 和destroy()方法。

可以设置autowire来进行自动装配，但是有时容易产生混乱，也可以在<beans>标签里面加上default-autowire。

然后是重点

看UserService.java这个类里面有个

private UserDAO userDAO;

然后我们为他写上get set方法。这样就可以通过配置文件注入这个对象。

我们注意到注入的bean ref=“u” 这个u和和上面声明的userDAO的id相同。

注入有3种方法第一种是上面注释的set方法注入第二种是上面的构造方法注入

因为我们在UserService里面有构造方法

private UserService(UserDAO userDAO) {
this.userDAO = userDAO;
}

所以我们必须要采用构造方法注入，如何注释掉构造方法就可以采用第一种。

第三种接口注入，没有去了解。

最后是一个junit测试类

package com.ouc.wkp.test;

import static org.junit.Assert.*;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ouc.wkp.dao.UserDAO;
import com.ouc.wkp.model.User;
import com.ouc.wkp.service.UserService;
//import com.ouc.wkp.spring.BeanFactory;
//import com.ouc.wkp.spring.ClassPathXmlApplicationContext;

public class UserServiceTest {

    @Test
    public void testAdd() throws Exception{
        ClassPathXmlApplicationContext ctx1=new ClassPathXmlApplicationContext("beans.xml");
        
        UserService service=(UserService)ctx1.getBean("userservice");
        UserService service2=(UserService)ctx1.getBean("userservice");
        
        System.out.println(service==service2);
        
        User user=new User();
        user.setUsername("heihei");
        user.setPassword("1234");
        service.add(user);
        
        
        
        
        ApplicationContext ctx2=new ClassPathXmlApplicationContext("beans1.xml");
        
        UserDAO userDAO=(UserDAO)ctx2.getBean("userDAO");
        
        System.out.println(userDAO);
    }

}

UserServiceTest.java

运行结果如下

上面使用的xml方式，下面介绍annotation方式，方便了很多。

首先需要在配置文件里面加上这些

xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd">
<context:annotation-config />

使用这种方式，我们就不需要在xml中声明bean。上面xml中的两个bean标签可以删去。

两个类作了修改

package com.ouc.wkp.dao.impl;

import org.springframework.stereotype.Component;

import com.ouc.wkp.dao.UserDAO;
import com.ouc.wkp.model.User;

@Component("u")
public class UserDAOImpl implements UserDAO {

    @Override
    public void save(User user) {
        // Hibernate
        // JDBC
        // XML
        // NetWork
        System.out.println("user saved!");
//        throw new RuntimeException();
    }

    @Override
    public void delete() {
        // TODO Auto-generated method stub
        
    }

}

UserDAOImpl

在类的开头写上@Component("u")

package com.ouc.wkp.service;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import com.ouc.wkp.dao.UserDAO;
import com.ouc.wkp.model.User;

@Component("userService")
public class UserService {

    private UserDAO userDAO;

    @PostConstruct
    public void init() {
        System.out.println("init");
    }

    public void add(User user) {
        userDAO.save(user);
    }

    public UserDAO getUserDAO() {
        return userDAO;
    }

    // @Autowired @Qualifier("u")
    @Resource(name = "u")
    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    @PreDestroy
    public void destroy() {
        System.out.println("destroy");
    }
}

UserService.java

在类的开头写上@Component("userService")

在初始化方法前面写上@PostConstruct

在销毁方法前面写上@PreDestroy

在setUserDAO前面写上@Resource(name = "u")

注意这个name=“u” 和@Component("u")的对应关系

下一篇简单介绍aop和两种实现形式

查看全文

相关阅读:
记一次vue.js用 http.post 前端传json到后台用javabean接收的坑
 springboot1.5.x 测试sample
sqlserver 查询表缺失索引
 Docker swarm上线的一些问题
 数据库日志文件压缩
 Docker 挂载
 单播广播和多播
 导入数据库表后某些字段的精度为0
Source Qualifiter组件中Sql Query属性的脚本返回结果集的列数大于组件定义的数量
 distinct和order by冲突

原文地址：https://www.cnblogs.com/wangkaipeng/p/5780143.html