栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Spring学习笔记——IOC篇

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Spring学习笔记——IOC篇

文章目录
  • xml配置
    • 创建和取出bean
      • 准备
      • 创建bean
      • 取出bean
    • 属性注入
      • 普通属性
      • 类属性
      • P空间和C空间
      • 集合和数组属性
      • util标签(创建集合)
    • 工厂方式创建bean
      • 静态工厂
      • 动态工厂
      • FactoryBean
    • bean的作用域
    • bean的生命周期
    • 自动装配
    • 引入外部配置文件
  • 注解配置
    • 准备
    • 创建和取出bean
    • 普通属性注入
    • 自动装配(类属性注入)
    • 完全注解开发
    • 常用注解

xml配置 创建和取出bean 准备

使用spring需要先将我们需要的包导入,需要导入如下包

通过maven导入的话只需要导入webmvc包,maven会自动将其他的依赖包导进来

 		
            org.springframework
            spring-webmvc
            5.3.18
        
创建bean

首先需要先创建一个xml配置文件,我创建配置文件为mybean.xml,内容如下:






接下来的配置都会在beans标签内配置。
然后创建一个Person用来测试。

public class Person {
    public void say(){
        System.out.println("你好");
    }
}

最后在配置文件中就可以配置一个bean了。在beans标签内配置一个bean标签:


其中bean标签表示我们要创建一个bean;id属性用来我们标记创建的bean,后面我们可以用id将bean取出来;class属性是类的路径。

取出bean

取出bean我们需要用到ApplicationContext接口和它的一个实现类ClassPathXmlApplicationContext。

 @Test
    public void testBean(){
        ApplicationContext app = new ClassPathXmlApplicationContext("mybean.xml");
        Person p = app.getBean("person",Person.class);
        p.say();
    }


除了ApplicationContex接口外还有一个BeanFactory接口也可以达到同样的效果,不过相比于ApplicationContex,BeanFactory接口的功能没那么多。
除了ClassPathXmlApplicationContext外还有FileSystemXmlApplicationContext也是这些接口的实现类,他们的区别是里面参数路径方式的不同,第一个是类路径,第二个是绝对路径。

属性注入 普通属性

在配置bean时,我们创建的类还可能会有属性,我们可以在配置bean时为这些属性也赋上相应的值。接下来将Person类修改一下

public class Person {
    private String name ;
    private int age;

    public  Person(){}
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }

    public void say(){
        System.out.println("你好,我是"+name+",今年"+age+"岁了。");
    }
}

这里为其加上了set方法、有参构造和无参构造。
修改配置文件如下:

	
        
        
    

在bean标签内用property标签为bean的属性赋值,需要注意,用propery标签为属性赋值时需要Person类有无参构造器和set方法,否则就会报错。
除了用property标签外,也可以用constructor-arg标签

    


        
        
    

他们都可以为属性赋值,并且用法基本一样,需要注意用constructor-arg标签需要有相应的有参构造器才可以,不然也是会报错的。
再次测试,结果如下:

类属性

创建一个UserDao接口

public interface UserDao {
    public void insert();
}

创建一个接口的实现类

public class UserDaoImpl implements UserDao{
    @Override
    public void insert() {
        System.out.println("插入数据...");
    }
}

创建一个UserService类

public class UserService {
    private UserDao uDao;

    public UserService(){}
    public UserService(UserDao uDao) {
        this.uDao = uDao;
    }

    public void setuDao(UserDao uDao) {
        this.uDao = uDao;
    }

    public void add(){
        uDao.insert();
    }
}

接下来在配置文件中配置如下内容:

	
    
        
		
    

可以看到和普通属性赋值差不多,只不过将value属性换成了ref属性。ref属性可以将前面配置的bean给引用过来,还有一种方式可以不用在前面配置userDao也可以为属性赋值,方式如下:

	



        
            
        
    

这种方式也可以为属性赋值,不过这种方式赋值内部的bean不可以被getBean。

编写测试代码,两种方式都测试一遍

    @Test
    public void testDi(){
        ApplicationContext app = new ClassPathXmlApplicationContext("mybean.xml");
        UserService userService = app.getBean("userService",UserService.class);
        userService.add();
    }


P空间和C空间

前面用property标签和constructor-arg标签赋值时如果属性太多会让xml配置文件显得很不美观而P空间和C空间就是用来简化property和constructor-arg标签的它们的格式如下:
普通属性:
p:属性名=[值]
c:属性名=[值]
类属性:
p:属性名-ref=[值]
c:属性名-ref=[值]
要使用P和C空间需要先加上约束


使用之前的Person类,在配置文件中使用P和C空间为属性赋值

    
    

测试

    @Test
    public void testPAndD(){
        ApplicationContext app = new ClassPathXmlApplicationContext("mybean.xml");
        Person p2 = app.getBean("person2",Person.class);
        Person p3 = app.getBean("person3",Person.class);
        p2.say();
        p3.say();
    }

集合和数组属性

创建Student类

public class Student {
    public Map name;
    public String[] hobby;
    public List courseList;
    public Set cardId;

    public void setName(Map name) {
        this.name = name;
    }

    public void setHobby(String[] hobby) {
        this.hobby = hobby;
    }

    public void setCourseList(List courseList) {
        this.courseList = courseList;
    }

    public void setCardId(Set cardId) {
        this.cardId = cardId;
    }
}

配置文件中内容如下:

    
        
        
            
                
                

            
        
        
        
            
                唱
                跳
                rap
                篮球

            
        
        
        
            
                数据结构
                Java程序设计

            
        
        
        
            
                1234
                5678

            
        
    

也可采用匿名bean的方式为集合和数组赋值,只需要将上述格式替换成如下格式:


            
                
                    
                        
                    
                    
                
                
                    
                        
                    
                    
                
            

            
                
                
            

            
                
                
            

            
                
                
            

测试

    @Test
    public void testArray(){
        ApplicationContext app = new ClassPathXmlApplicationContext("mybean.xml");
        Student s = app.getBean("student", Student.class);
        
        System.out.println("——名字——");
        System.out.println(s.name.get("大名"));
        System.out.println(s.name.get("小名"));
        System.out.println("——爱好——");
        for(String str:s.hobby)
            System.out.println(str);
        System.out.println("——课程——");
        Iterator it = s.courseList.iterator();
        while(it.hasNext())
            System.out.println(it.next());
        System.out.println("——银行卡——");
        Iterator it2 = s.cardId.iterator();
        while (it2.hasNext())
            System.out.println(it2.next());

    }

util标签(创建集合)

util标签可以帮助我们创建集合供所有需要集合属性的属性引用它们,通过util标签创建的集合也可以通过id被getBean。还是用上节的Student类做演示,使用util标签需要先引入约束。



修改配置文件


    
        
        
    
    
        数据结构
        Java程序设计
    
    
        1234
        5678
    
    

    
        
        
            
                唱
                跳
                rap
                篮球
            
        
        
        
    

测试

    @Test
    public void testArray(){
        ApplicationContext app = new ClassPathXmlApplicationContext("mybean.xml");
        Student s = app.getBean("student", Student.class);
        System.out.println("——名字——");
        System.out.println(s.name.get("大名"));
        System.out.println(s.name.get("小名"));
        System.out.println("——爱好——");
        for(String str:s.hobby)
            System.out.println(str);
        System.out.println("——课程——");
        Iterator it = s.courseList.iterator();
        while(it.hasNext())
            System.out.println(it.next());
        System.out.println("——银行卡——");
        Iterator it2 = s.cardId.iterator();
        while (it2.hasNext())
            System.out.println(it2.next());

    }

工厂方式创建bean 静态工厂

还用普通属性那节的Person类,然后创建一个静态工厂

public class StaticPersonFactory {
    public static Person getPerson(String name,int age){
        return new Person(name,age);
    }
}

配置文件内容

    
        
        
    

注意:使用constructor-arg还是property取决于工厂方法是有参数还是无参数,如果有参数则需要用constructor-arg为属性赋值,如果没有参数则用property为属性赋值。整个工厂方法可以理解为一个Person的构造器,如果是有参的当然要使用constructor-arg标签了,如果是无参的只能使用property标签为属性赋值啦。

测试

    @Test
    public void testStaticFactory(){
        ApplicationContext app = new ClassPathXmlApplicationContext("mybean.xml");
        Person p = app.getBean("factoryPerson",Person.class);
        p.say();
    }

动态工厂

同样使用Person类,接下来创建一个动态工厂

public class PersonFactory {
    public Person getPerson(){
        return new Person();
    }
}

配置文件内容如下


    
    
        
        
    

这种方式和静态工厂方式基本一致,不同的是需要我们先将工厂类配置一下才能在后面的factory-bean引用工厂类,其他的都一样。

测试

    @Test
    public void testFactory(){
        ApplicationContext app = new ClassPathXmlApplicationContext("mybean.xml");
        Person p = app.getBean("factoryPerson2",Person.class);
        p.say();
    }

FactoryBean

FactoryBean是Spring留出的工厂接口,通过这个接口我们也可以创建Person类。接下来创建一个工厂类实现这个接口。

public class PersonFactoryBean implements FactoryBean {
    private String pName;
    private int pAge;

    public PersonFactoryBean(String pName, int pAge) {
        this.pName = pName;
        this.pAge = pAge;
    }
    public PersonFactoryBean(){}


    public void setpName(String pName) {
        this.pName = pName;
    }
    public void setpAge(int pAge) {
        this.pAge = pAge;
    }

    @Override
    public Person getObject() throws Exception {
        Person p = new Person();
        p.setName(pName);
        p.setAge(pAge);
        return p;
    }

    @Override
    public Class getObjectType() {
        return Person.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

注意:该接口是一个泛型接口,注意添加泛型参数。
实现该接口需要实现三个方法,分别是getObject、getObjectType、isSingleton。
第一个方法返回工厂类要创建的类实例,第二个方法返回它的class对象,第三个方法决定创建的类是否为单例,什么是单例会在后面作用域说。
可以看到我们在工厂类中添加了一些set方法和构造器,这是专门为我们的Person类属性赋值的,使用此种方式不能像前两种一样使用Person类自己的构造器和set方法赋值。
FactoryBean是用来管理复杂bean的创建,通过该接口自定义创建bean的过程。

配置文件内容如下


    
        
        


    

测试

    @Test
    public void testFactoryBean(){
        ApplicationContext app = new ClassPathXmlApplicationContext("mybean.xml");
        Person p = app.getBean("factoryPerson3",Person.class);
        p.say();
    }

bean的作用域

作用域主要介绍两种

  1. singleton 单例模式,每次getBean都是同一个实例。
  2. prototype 原型模式 每次getBean都是不同的实例。

设置作用域需要用到bean标签内的scope属性。

测试singleton

    
        
        
    
    @Test
    public void testBean(){
        ApplicationContext app = new ClassPathXmlApplicationContext("mybean.xml");
        Person p1 = app.getBean("person",Person.class);
        Person p2 = app.getBean("person",Person.class);
        Person p3 = app.getBean("person",Person.class);
        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p3);
    }


测试prototype

    
        
        
    
    @Test
    public void testBean(){
        ApplicationContext app = new ClassPathXmlApplicationContext("mybean.xml");
        Person p1 = app.getBean("person",Person.class);
        Person p2 = app.getBean("person",Person.class);
        Person p3 = app.getBean("person",Person.class);
        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p3);
    }

bean的生命周期

bean的生命周期主要有如下步骤:

  1. 通过构造器创建bean实例
  2. 调用set方法为属性赋值
  3. 调用bean的初始化方法(需配置)
  4. 容器关闭时调用bean的销毁方法(需配置)

创建测试类

public class BeanLife {
    private String name;

    public BeanLife(){
        System.out.println("第一步,调用构造器");
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("第二步,调用set方法");
    }

    //初始化方法
    public void initMethod(){
        System.out.println("第三步,调用初始化方法");
    }

    //销毁方法
    public void destroyMethod(){
        System.out.println("第四步,调用销毁方法");
    }
}

在配置文件中配置初始化方法和销毁方法

    
            
    

测试

    @Test
    public void testLife(){
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("mybean.xml");
        BeanLife life = app.getBean("life",BeanLife.class);

        //关闭容器
        app.close();
    }


后置处理器BeanPostProcessor
BeanPostProcessor是一个接口,该接口有两个方法,这两个方法分别在bean的初始化方法前后执行。实现该接口的类就拥有后置处理器的功能,需要我们在配置文件将后置处理器配置一下,配置后所有的bean的初始化方法执行前后都会执行后置处理器的这两个方法。
其一般步骤是,bean执行set方法后将bean实例传给后置处理器的postProcessBeforeInitialization方法,然后执行bean的初始化方法,再然后是将bean实例传给后置处理器的postProcessAfterInitialization方法,最后就是容器关闭执行bean的销毁方法。

修改BeanLife类

public class BeanLife {
    private String name;

    public BeanLife(){
        System.out.println("第一步,调用构造器");
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("第二步,调用set方法");
    }

    //初始化方法
    public void initMethod(){
        System.out.println("第四步,调用初始化方法");
    }

    //销毁方法
    public void destroyMethod(){
        System.out.println("第六步,调用销毁方法");
    }
}

创建后置处理器类

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第三步,调用后置处理器Before方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第五步,调用后置处理器After方法");
        return bean;
    }
}

第一个bean参数为bean的实例对象。

在配置文件中配置bean和后置处理器

    
            
    


    


可以看到有好多个第三步和第五步,这是因为前面做测试在这个配置文件配置了许多别的bean,所以每个bean都触发了后置处理器。从最后的六步可以看出整个bean的生命周期,验证了我们所说的六步骤。

自动装配

前面我们为类属性赋值时都是手动的用property标签或constructor-arg标签,而自动装配就是不用我们手动的去引用配置过的bean,spring容器会根据需要自动装配的bean的属性的类型或属性名在容器中查找符合条件的bean并帮我们赋值。
要使用自动装配需要使用bean标签的autowire属性,主要说一下它的两个取值:

  1. byName 根据类属性的属性名在spring容器中查找bean的id名
  2. byType 根据类属性的类型在spring容器中查找bean的类型

测试byName
创建测试类

public interface UserDao {
    public void insert();
}
public class UserDaoImpl implements UserDao{
    @Override
    public void insert() {
        System.out.println("插入数据...");
    }
}
public class UserService {
    private UserDao uDao;

    public UserService(){}
    public UserService(UserDao uDao) {
        this.uDao = uDao;
    }

    public void setuDao(UserDao uDao) {
        this.uDao = uDao;
    }

    public void add(){
        uDao.insert();
    }
}

配置文件内容

    
    

测试

    @Test
    public void testDi(){
        ApplicationContext app = new ClassPathXmlApplicationContext("mybean.xml");
        UserService userService = app.getBean("userService",UserService.class);
        userService.add();
    }


如果更改UserService类中的属性名或者更改id为uDao的bean,spring就会因为找不到bean而报错。
测试byType
更改一下配置文件的内容

    
    

将第一个bean的id更改,并且将autowire设置为byType。

测试

    @Test
    public void testDi(){
        ApplicationContext app = new ClassPathXmlApplicationContext("mybean.xml");
        UserService userService = app.getBean("userService",UserService.class);
        userService.add();
    }

引入外部配置文件

在开发过程中,我们如果将所有的配置信息都写到xml配置文件中,就会让配置文件显得很杂很乱影响阅读,这是我们需要将一些配置的内容写到一些外部的配置文件,然后我们在xml配置文件中引用它们。
下面用一个连接数据库作为例子,需要先导入mysql的jar包

        
            mysql
            mysql-connector-java
            8.0.26
        

创建外部配置文件db.properties

db.url=jdbc:mysql://localhost:3306/test
db.username=root
db.password=12345678
db.driverClassName=com.mysql.cj.jdbc.Driver

创建工具类

public class DBUtils {
    private String username;
    private String password;
    private String url;
    private String driverClassName;

    public void setUsername(String username) {
        this.username = username;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }


    public Connection getConn(){
        Connection conn = null;
        try {
            Class.forName(driverClassName);
            conn = DriverManager.getConnection(url,username,password);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }
}

在配置文件中引入context约束


在配置文件中配置外部文件并引用内容


    
    
        
        
        
        
    

引用配置文件的内容只需要用${ }括起来就行。

测试

    @Test
    public void testConfigFile() throws SQLException {
        ApplicationContext app = new ClassPathXmlApplicationContext("mybean.xml");
        DBUtils db = app.getBean("dbUtils",DBUtils.class);
        Connection conn = db.getConn();

        System.out.println(conn);

        conn.close();

    }

注解配置 准备

创建新的配置文件mybean2.xml,使用注解需要先引入context约束





接下来的配置都会在beans标签内配置。

开启组件扫描
要想使注解生效需要先将组件扫描开启,扫描指定的路径。


    

该标签会扫描指定的包,使包内的注解生效。这个标签还有两个子标签这两个子标签的功能是扫描指定内容或排除某些内容不扫描。

    

        
        

        
    

这两个子标签使用一个就可以了为了演示方便我都写了,要使子标签功能生效需将父标签的use-default-filters属性为false。

创建和取出bean

使用注解创建一个bean需要了解下面几个注解

  1. @Component 用于普通类
  2. @Controller 用于控制层的类
  3. @Service 用于业务层的类
  4. @Repository 用于持久层的类
    这四个注解功能是一样的,都是将被标记的类放入spring容器,不过最好还是按照规定用吧。

创建一个User类并写上注解

@Component("user")
public class User {
    public void say(){
        System.out.println("你好");
    }
}

注解中有一个参数,就是bean的id名,如果不写默认就是类名首字母小写。

测试

    @Test
    public void testUser(){
        ApplicationContext app = new ClassPathXmlApplicationContext("mybean2.xml");
        User u = app.getBean("user",User.class);
        u.say();
    }


没有在配置文件中配置bean也可以取出来。

普通属性注入

为普通属性赋值需要用到@Value注解。
将User类修改一下。

@Component("user")
public class User {
    
    @Value("张三")
    private String name;
    
    @Value("18")
    private int age;
    
    public void say(){
        System.out.println("你好,我是"+name+",今年"+age+"岁了。");
    }
}

这个注解不仅可以放在属性上边也可以放在set方法上,效果是一样的。

测试

    @Test
    public void testUser(){
        ApplicationContext app = new ClassPathXmlApplicationContext("mybean2.xml");
        User u = app.getBean("user",User.class);
        u.say();
    }

自动装配(类属性注入)

自动装配有下面几个注解

  1. @Autowired 根据类型找
  2. @Qualifier 根据传入的参数名称找
  3. @Resource 根据类型和名称找
    前两个注解是spring提供的最后一个是jdk自带的

创建测试类

public interface UserDao {
    public void insert();
}
@Repository("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public void insert() {
        System.out.println("插入数据...");
    }
}
@Service("userService")
public class UserService {

    //@Resource(name = "userDao",type = UserDao.class)
    @Autowired
    @Qualifier("userDao")
    private UserDao uDao;

    public void add(){
        uDao.insert();
    }
}

被注释的@Resource功能和使用 @Autowired、@Qualifier(“userDao”)是一样的。
注意:@Autowired可以单独使用,但是@Qualifier必须和@Autowired一起使用不然会报错。

测试

    @Test
    public void testUserService(){
        ApplicationContext app = new ClassPathXmlApplicationContext("mybean2.xml");
        UserService u = app.getBean("userService", UserService.class);
        u.add();
    }

完全注解开发

所谓完全注解开发就是完全脱离xml配置文件,也就是可以不用创建配置文件了,所有配置都用注解完成,前面在xml可以完成的功能使用注解也基本可以做到。

创建一个配置类并用@Configuration注解标记,后面的一些配置就可以在配置类中用注解配置。

@Configuration
public class MyConfig {
}

开启组件扫描使用@ComponentScan注解

@Configuration
@ComponentScan("chy.spring.ioc.annotation")
public class MyConfig {
}

加载配置类使用AnnotationConfigApplicationContext这个实现类

    @Test
    public void test(){
        ApplicationContext app = new AnnotationConfigApplicationContext(MyConfig.class);
    }

这样后面的开发就可以都使用注解了。

测试

@Component("user")
public class User {

    @Value("张三")
    private String name;

    @Value("18")
    private int age;

    public void say(){
        System.out.println("你好,我是"+name+",今年"+age+"岁了。");
    }
}
@Configuration
@ComponentScan("chy.spring.ioc.annotation")
public class MyConfig {
}
    @Test
    public void test(){
        ApplicationContext app = new AnnotationConfigApplicationContext(MyConfig.class);
        User u = app.getBean("user",User.class);
        u.say();
    }

常用注解
注解介绍
@Import可以导入某个类到spring容器中,用法为@Import(UserFactory.class),要将该注解放到配置类上
@Bean可以标记到方法上,表示注册一个bean,可以将其放到动态或静态工厂的方法上
@Scope设置bean的作用域
@PostConstruct设置bean的初始化方法
@PreDestroy设置bean的销毁方法
@PropertySource引入外部配置文件
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/966527.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号