zoukankan html css js c++ java

Spring基础-02

AirPlane.java:

import lombok.Data;

/**
 * @Title: AirPlane
 * @Description:
 * @Author:
 * @Version: 1.0
 * @create 2020/6/5 20:38
 */
@Data
public class AirPlane {

    private String fdj;//发动机
    private String yc;//机翼长度
    private Integer personNum;//载客量
    private String jzName;//机长名字
    private String fjsName;//副驾驶

}

Book.java:

import lombok.Data;
import lombok.ToString;

/**
 * @Title: Book
 * @Description:
 * @Author:
 * @Version: 1.0
 * @create 2020/6/5 11:18
 */
@Data
@ToString
public class Book {

    private String bookName;
    private String author;

    public void myInit(){
        System.out.println("这是图书的初始化方法...");
    }

    public void myDestroy(){
        System.out.println("这是图书的销毁方法...");
    }

    public Book() {
        System.out.println("Book被创建...");
    }
}

Car.java:

import lombok.Data;
import lombok.ToString;

/**
 * @Title: Car
 * @Description:
 * @Author:
 * @Version: 1.0
 * @create 2020/6/5 11:16
 */
@Data
@ToString
public class Car {

    private String carName;
    private Integer price;
    private String color;

    public Car() {
        System.out.println("Car被创建...");
    }
}

MyBeanPostProcessor.java:

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * 1.编写后置处理器的实现类
 * 2.将后置处理器注册在配置文件中
 */
public class MyBeanPostProcessor implements BeanPostProcessor {

    /**
     * postProcessBeforeInitialization
     * 初始化之前调用
     * Object bean：将要初始化的bean
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization["+beanName+"]bean将要调用初始化方法了..."+bean);
        //返回传入的bean
        return bean;
    }


    /**
     * postProcessAfterInitialization
     * 初始化方法之后调用
     * String beanName：xml中配置的id
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization["+beanName+"]bean初始化方法调用完了...AfterInitialization");
        //初始化之后返回的bean：返回的是什么，容器中保存的就是什么
        return bean;
    }
}

Person.java:

import lombok.Data;
import lombok.ToString;

import java.util.List;
import java.util.Map;
import java.util.Properties;

/**
 * @Title: Person
 * @Description:
 * @Author:
 * @Version: 1.0
 * @create 2020/6/4 21:47
 */
@Data
@ToString
public class Person {

    private String lastName = "小明";
    private Integer age;
    private String gender;
    private String email;
    private Double salary;

    private Car car;

    private List<Book> books;

    private Map<String,Object> maps;

    private Properties properties;

    //容器中对象的创建在容器创建完成的时候就已经创建好了
    public Person() {
        System.out.println("Person创建了...");
    }

    public Person(String lastName, Integer age, String gender, String email) {
        this.lastName = lastName;
        this.age = age;
        this.gender = gender;
        this.email = email;
        System.out.println("有参构造器...");
    }

    public Person(Car car) {
        this.car = car;
        System.out.println("可以为car赋值的有参构造器...");
    }
}

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        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 5 
 6     <!--创建带有生命周期方法的bean
 7         生命周期：bean的创建和销毁
 8             ioc容器中注册的bean
 9                 1）单例bean，容器启动的时候就会创建好，容器关闭也会销毁创建的bean
10                 2）多实例bean：获取的时候才创建
11             我们可以为bean自定义一些生命周期方法，spring在创建或者销毁的时候就会调用指定的方法
12             自定义初始化方法和销毁方法：可以抛出异常，但是不可以有参数
13     -->
14     <bean id="book01" class="com.atguigu.bean.Book" destroy-method="myDestroy" init-method="myInit"></bean>
15     <bean id="book02" class="com.atguigu.bean.Book" destroy-method="myDestroy" init-method="myInit" scope="prototype"></bean>
16 
17     <!--测试bean的后置处理器：BeanPostProcessor
18         后置处理器：Spring有一个接口，可以在bean的初始化前后调用方法
19     -->
20     <bean id="beanPostProcessor" class="com.atguigu.bean.MyBeanPostProcessor"></bean>
21 
22     <bean class="com.atguigu.bean.Car" id="car01"></bean>
23 
24 </beans>

applicationContext02.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:context="http://www.springframework.org/schema/context"
 5        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
 6 
 7     <!--引用外部属性文件★ 依赖context，名称空间-->
 8     <!--数据库连接池作为单实例是最好的，一个项目就是一个连接池，连接池里面管理很多连接，连接是直接从连接池中拿-->
 9     <!--可以让spring帮我们创建连接池对象，管理连接池-->
10     <!--加载外部配置文件
11         固定写法classpath：表示引用类路径下的一个资源
12     -->
13     <context:property-placeholder location="classpath:db.properties"/>
14 
15     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
16         <!--${key}：动态取出配置文件中某个key对应的值-->
17         <!--username是Spring的key中的一个关键字：为了防止配置文件中的key和spring的关键字冲突-->
18         <property name="user" value="${jdbc.username}"></property>
19         <property name="password" value="${jdbc.password}"></property>
20         <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
21         <property name="driverClass" value="${jdbc.dirverClass}"></property>
22     </bean>
23 
24     <bean id="car01" class="com.atguigu.bean.Car">
25         <property name="carName" value="${username}"></property>
26     </bean>
27 
28     <!--基于XML的自动装配（自定义类型自动赋值）
29         javaBean（基本类型）
30             自定义类型的属性是一个对象，这个对象在容器中可能存在
31 
32     -->
33 
34 
35 </beans>

applicationContext03.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:context="http://www.springframework.org/schema/context"
 5        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
 6 
 7 
 8     <!--基于XML的自动装配（自定义类型自动赋值）
 9         javaBean（基本类型）
10             自定义类型的属性是一个对象，这个对象在容器中可能存在
11     -->
12     <!--id="car" id必须为car 因为private Car car;-->
13     <bean class="com.atguigu.bean.Car" id="car">
14         <property name="carName" value="宝马"></property>
15         <property name="color" value="白色"></property>
16     </bean>
17 
18     <!--<bean class="com.atguigu.bean.Car" id="car02">
19         <property name="carName" value="宝马"></property>
20         <property name="color" value="白色"></property>
21     </bean>-->
22 
23     <!--为Person里面的自定义类型的属性赋值
24         property：手动赋值
25         自动装配：仅对于自定义类型的属性有效
26         自动赋值（自动装配）：autowire
27             autowire="default"/autowire="no"：不自动装配，不自动为car属性赋值
28             //按照某种规则自动装配
29             autowire="byName"：按照名字
30                 private Car car
31                     以属性名作为id（car）去容器中找到这个组件，给它赋值。如果找不到，就装配null
32                     car = ioc.getBean("car")
33             autowire="byType"：按照类型
34                 private Car car
35                     1）以属性的类型作为查找依据去容器中找到这个组件
36                     如果容器中有多个这个类型的组件，报错
37                     NoUniqueBeanDefinitionException: No qualifying bean of type 'com.atguigu.bean.Car' available
38                     expected single matching bean but found 2
39                     2）如果没找到，装配null
40                     car = ioc.getBean(Car.class)
41 
42             autowire="constructor"：按照构造器
43                 public Person(Car car)
44                 1）先按照有参构造器参数的类型进行装配，没有就直接为组件装配null即可
45                 2）如果按照类型找到了多个：参数名作为id(car)继续匹配，找到就装配，找不到就null
46                 3）不会报错
47 
48     -->
49     <bean class="com.atguigu.bean.Person" id="person" autowire="byType">
50         <!--<property name="car" ref="car"></property>-->
51     </bean>
52 
53     <!--List<Books> books：容器可以把容器中所有的book封装list赋值给这个属性-->
54     <bean class="com.atguigu.bean.Book" id="book01">
55         <property name="bookName" value="图书1"></property>
56     </bean>
57 
58     <bean class="com.atguigu.bean.Book" id="book02">
59         <property name="bookName" value="图书2"></property>
60     </bean>
61 
62     <bean class="com.atguigu.bean.Book" id="book03">
63         <property name="bookName" value="图书3"></property>
64     </bean>
65 
66     <!--
67         [SpEL测试I]（Spring Expression Language）
68         在SpEL中使用字面量、
69         引用其他bean、
70         引用其他bean的某个属性值、
71         调用非静态方法
72         调用静态方法、
73         使用运算符
74     -->
75     <bean class="com.atguigu.bean.Person" id="person04">
76         <!--字面量：${} spring：#{}-->
77         <property name="salary" value="#{12345.67*12}" />
78         <!--引用其他bean的某个属性值-->
79         <property name="lastName" value="#{book01.bookName}"/>
80         <!--引用其他bean-->
81         <property name="car" value="#{car}"/>
82         <!--
83             调用静态方法：UUID.randomUUID().toString()
84             #{T(全类名).静态方法名(1,2)}
85         -->
86         <property name="email" value="#{T(java.util.UUID).randomUUID().toString()}"/>
87         <!--调用非静态方法：对象.方法名-->
88         <property name="gender" value="#{book01.getBookName()}"/>
89         <!--或者-->
90         <!--<property name="gender" value="#{book01.bookName}"/>-->
91 
92     </bean>
93 </beans>

db.properties:

jdbc.username=root
jdbc.password=root
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/greatshop?serverTimezone=GMT%2B8
jdbc.dirverClass=com.mysql.cj.jdbc.Driver

IOCTest.java:

 1 import com.atguigu.bean.Car;
 2 import com.atguigu.bean.Person;
 3 import org.junit.Test;
 4 import org.springframework.context.ApplicationContext;
 5 import org.springframework.context.ConfigurableApplicationContext;
 6 import org.springframework.context.support.ClassPathXmlApplicationContext;
 7 
 8 import javax.sql.DataSource;
 9 import java.sql.SQLException;
10 
11 /**
12  * @Title: IOCTest
13  * @Description:
14  * @Author:
15  * @Version: 1.0
16  * @create 2020/6/5 22:47
17  */
18 public class IOCTest {
19 
20     //    ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
21     ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext03.xml");
22 
23     /**
24      * 单例bean的生命周期
25      * （容器启动）构造器--->初始化方法--->销毁方法
26      * <p>
27      * 多实例：
28      * 获取bean（构造器--->初始化方法）--->容器关闭不会调用bean的销毁方法
29      *
30      * 后置处理器：
31      *      （容器启动）构造器-----后置处理器before-----初始化方法-----后置处理器after-----初始化完成
32      * 无论bean是否有初始化方法，后置处理器都会默认其有，还会继续工作
33      */
34 
35     @Test
36     public void test() {
37         System.out.println("容器关闭了...");
38         ioc.close();
39     }
40 
41     @Test
42     public void test02() {
43         Object book02 = ioc.getBean("book02");
44         System.out.println("容器关闭了...");
45         ioc.close();
46     }
47 
48     @Test
49     public void test03() {
50         Object book01 = ioc.getBean("book01");
51         System.out.println(book01);
52         ioc.close();
53     }
54 
55     @Test
56     public void test04() throws SQLException {
57         //1.从容器中拿到连接池
58         //按照类型获取组件，可以获取到这个类型下的所有实现类子类等等
59         DataSource dataSource = ioc.getBean(DataSource.class);
60         System.out.println(dataSource.getConnection());
61     }
62 
63     //测试username到底是什么
64     @Test
65     public void test05(){
66         String carName = ioc.getBean("car01", Car.class).getCarName();
67         System.out.println(carName);//系统用户名
68     }
69 
70     //建源码文件夹才会读取配置文件的信息
71 
72     //
73     /**
74      * 测试基于xml的自动装配
75      * 容器中只有一个Person，可以直接写类，无需写id
76      */
77     @Test
78     public void test06(){
79         Person person = ioc.getBean(Person.class);
80         System.out.println(person);
81 
82     }
83 
84     @Test
85     public void test07(){
86         Person person = ioc.getBean("person04",Person.class);
87         System.out.println(person);
88 
89     }
90 }

查看全文

相关阅读:
接口和抽象的区别
 继承-子父类中成员方法特点
 基本类型和引用类型作为参数传递
 大三寒假生活6
大三寒假生活5
大三寒假生活4
大三寒假生活3
大三寒假生活2
大三寒假生活指导
 ajax实现文本框的联想功能

原文地址：https://www.cnblogs.com/116970u/p/13059757.html

最新文章
CGLib动态代理
 Java动态代理的理解
 ThreadLocal的使用和理解
 线性表
 数据结构介绍
 JSON操作
 XML操作
 网络
 文件操作
 2D游戏摄像机跟随不出界