第三次作业随想篇：Spring入门

1. 简单了解Spting的 AOP 和 IOC 概念
　　AOP: Aspect Oriented Program, 面向(方面)切面的编程;Filter(过滤器)也是一种 AOP. AOP 是一种新的 方法论, 是对传统 OOP(Object-Oriented
　　　　Programming, 面向对象编程) 的补充. AOP 的主要编程对象是切面(aspect),而切面模块化横切关注点.可以举例通过事务说明.

　　IOC: Invert Of Control, 控制反转. 也成为 DI(依赖注入)其思想是反转资源获取的方向. 传统的资源查找方式要求组件向容器发起请求查找资源.作为
　　　　回应, 容器适时的返回资源. 而应用了 IOC 之后, 则是容器主动地将资源推送给它所管理的组件,组件所要做的仅是选择一种合适的方式来接受资源. 这种行
　　　　为也被称为查找的被动形式

2.在 Spring 中如何配置 Bean ?
　　Bean 的配置方式: 通过全类名 （反射）、 通过工厂方法 （静态工厂方法 & 实例工厂方法）、FactoryBean
　　
下面具一个简单地例子说明

首先基于配置的方式：

　　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"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

   <bean id="address1" class="autowire.Address" 
   p:city="baoshan" p:street="lehong"></bean>
   
   <bean id="address2" class="autowire.Address"
   p:city="xiangtan" p:street="qiujier"></bean>
   
   <bean id="car1" class="autowire.Car"
    p:brand="benchi" p:price="500000"></bean>
   
   <bean id="person1" class="autowire.Person" 
   p:name="hepan1" p:address-ref="address2" p:car-ref="car1"></bean>
</beans>

相应的类文件：

    Address.java

package autowire;

public class Address {
    private String city;
    private String street;
    
    public String getCity() {
        return city;
    }
    public void setCity(String city) {
        this.city = city;
    }
    public String getStreet() {
        return street;
    }
    public void setStreet(String street) {
        this.street = street;
    }
    @Override
    public String toString() {
        return "Address [city=" + city + ", street=" + street + "]";
    }
    
}

　　Car.java

package autowire;

public class Car {
   private String brand;
   private double price;
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Car [brand=" + brand + ", price=" + price + "]";
    }
    
}

      Person.java

package autowire;

public class Person {
   private String name;
   private Address  address;
   private Car car;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Address getAddress() {
        return address;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
    public Car getCar() {
        return car;
    }
    public void setCar(Car car) {
        this.car = car;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", address=" + address + ", car=" + car
                + "]";
    }

       
}

      测试的main方法

package autowire;

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

public class Main {

    public static void main(String[] args) {
        
    ApplicationContext ctx=new ClassPathXmlApplicationContext("relation.xml");
    Person person=(Person) ctx.getBean("person1");
    System.out.println(person);
    }

}

     配置成功输出

 

 

 2.测试Bean的生命周期

　　IOC 容器对 Bean 的生命周期:
　　　　①. 通过构造器或工厂方法创建 Bean 实例
　　　　②. 为 Bean 的属性设置值和对其他 Bean 的引用
　　　　③ . 将 Bean 实 例 传 递 给 Bean 后 置 处 理 器 的postProcessBeforeInitialization 方法
　　　　④. 调用 Bean 的初始化方法(init-method)
　　　　⑤ . 将 Bean 实 例 传 递 给 Bean 后 置 处 理 器 的postProcessAfterInitialization 方法
　　　　⑦. Bean 可以使用了
　　　　⑧. 当容器关闭时, 调用 Bean 的销毁方法(destroy-method)

首先建立beanlife.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.xsd">

   <bean id="car" class="beanlife.Car" init-method="init" destroy-method="destory">
    <property name="brand" value="benchi"></property>
   </bean>
   
   <bean class="beanlife.BeanpostProcessor">
    
   </bean>
</beans>

实现Bean的构造器

package beanlife;

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

public class BeanpostProcessor implements BeanPostProcessor {

    public Object postProcessAfterInitialization(Object arg0, String arg1)
            throws BeansException {
        Car car=new Car();
        car.setBrand("Foed");
        System.out.println("postProcessAfterInitialization  "+arg1);
        return car;
    }

    public Object postProcessBeforeInitialization(Object arg0, String arg1)
            throws BeansException {
        System.out.println("postProcessBeforeInitialization  "+arg1);
        return arg0;
    }

}

将要被实例化的类

package beanlife;

public class Car {
   @Override
    public String toString() {
        return "Car [brand=" + brand + "]";
    }

Car()
   {
       System.out.println("bean被初始化-----------");
   }
   
   public String getBrand() {
    return brand;
    }
    public void setBrand(String brand) {
         System.out.println("Car set");
        this.brand = brand;
    }

  private String brand;
   
   void init()
   {
       System.out.println("init");
   }
   void destory()
   {
       System.out.println("bean被销毁--------------");
   }
}

主要测试Main方法

package beanlife;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

    
    public static void main(String[] args) {
        ApplicationContext ctx=new ClassPathXmlApplicationContext("beanlife.xml");
        Car car=(Car) ctx.getBean("car");
        System.out.println(car);
        
        ((AbstractApplicationContext) ctx).close();
    }

}

输出：

就可以看见bena被创建和销毁的过程了。

 

3.Spring与数据库的交互即配置相应的与数据库连接信息

　　配置连接的信息

<?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.xsd">

   <!-- bean的属性配置可以用来来连接数据库 ,数据连接池使用的是c3p0的数据源
       配置最基本的数据库连接有四个-->
   <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
       <property name="user" value="scott"></property>
       <property name="password" value="orcl"></property>
       <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
       <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/itcasttax1"></property>
       <property name="initialPoolSize" value="10"></property>
        <!--连接池中保留的最小连接数。Default: 3 -->
        <property name="minPoolSize" value="3"></property>
        <!--连接池中保留的最大连接数。Default: 15 -->
        <property name="maxPoolSize" value="10"></property>
        <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
        <property name="acquireIncrement" value="3"></property>
        <!--最大空闲时间，1800秒内未使用则连接被丢弃，若为0则永不丢弃。Default: 0 -->
        <property name="maxIdleTime" value="1800"></property>
   </bean>
</beans>

测试数据库是否连接成功的main方法

package property;

import java.sql.SQLException;

import javax.sql.DataSource;

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

public class Main {

    public static void main(String[] args) throws SQLException {
    
        ApplicationContext ctx=new ClassPathXmlApplicationContext("beans-property.xml");
        DataSource dt=(DataSource) ctx.getBean("dataSource");
        System.out.println(dt.getConnection());
        System.out.println("数据库连接succeess。。。。。");
    }

}

连接成功则输出

表明数据库连接成功