spring01

public class JdbcDemo1{

publicstaticvoidmain(String[] args)throws SQLException{

//1、注册驱动

DriverManager.registerDriver(newcom.mysql.jdbc.Driver());

//2、获取连接ConnectionConnection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/spring5","root","123456");

//3、获取操作数据库的预处理对象PreparedStatmentPreparedStatement pstm = conn.prepareStatement("SELECT * FROM account");

//4、执行SQL语句，获得结果集ResultSet resultSet = pstm.executeQuery();//

5、遍历结果集while(resultSet.next()){ System.out.println(resultSet.getString("name")); }

//6、关闭资源resultSet.close(); pstm.close(); conn.close(); }}

工厂类对象

/********

*   一个创建Bean对象的工厂

*

*   第一个：需要一个配置文件来配置我们的service和dao

*              配置的内容：唯一标识=全限定类名（key=value)

*   第二个：通过读取配置文件中配置的内容，反射创建对象

*   我的配置文件可以是xml也可以是properties

******/

public class BeanFactory {

    //定义衣蛾Properties对象，用于存放解析的配置信息

    private static Properties props = new Properties();;

    //存储

    private static Map<String,Object> beans = new HashMap<String, Object>();

    //使用静态块为props对象赋值

    static {

        try {

            //读取配置文件

            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");

            //加载配置文件字节输入流

            props.load(in);

            //读取配置文件，获取所有的key

            Enumeration<Object> keys = props.keys();

            //遍历所有的key

            while (keys.hasMoreElements()){

                //获得key

                String key = keys.nextElement().toString();

                //获取key对应的类全限定名

                String beanPath = (String) props.get(key);

                //获取字节码对象

                Object value = Class.forName(beanPath).newInstance();

                //把key和value存入容器中

                beans.put(key,value);

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    /***

     * 根据Bean的名称获取对象

     * @param beanName

     * @return

     */

    public static Object getBean(String beanName){

        return  beans.get(beanName);

    }

}

<dependencies>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>5.0.2.RELEASE</version>

</dependency>

</dependencies>

<dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<version>4.12</version>

</dependency>

<!--

        bean标签：用于配置让spring创建对象，并且存入ioc容器之中

           id属性：对象的唯一标识。

           class属性：指定要创建对象的全限定类名

    -->

    <!-- 配置service -->

    <bean id="accountService" class="com.oppo.service.impl.AccountServiceImpl"></bean>

    <!-- 配置dao -->

    <bean id="accountDao" class="com.oppo.dao.impl.AccountDaoImpl"></bean>

  //1.使用ApplicationContext接口，就是在获取spring容器

        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

        //2.根据bean的id获取对象

        AccountService accountService = (AccountService) ac.getBean("accountService");

        System.out.println(accountService);

        AccountDao accountDao = (AccountDao) ac.getBean("accountDao");

        System.out.println(accountDao);

BeanFactory才是Spring容器中的顶层接口。

ApplicationContext是它的子接口。

BeanFactory和ApplicationContext的区别：

    创建对象的时间点不一样。

       ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。

       BeanFactory：什么使用什么时候创建对象

       ClassPathXmlApplicationContext：

    它是从类的根路径下加载配置文件       推荐使用这种

FileSystemXmlApplicationContext：

    它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。

AnnotationConfigApplicationContext:

    当我们使用注解配置容器对象时，需要使用此类来创建spring容器。它用来读取注解。

bean 标签

作用：

    用于配置对象让spring来创建的。

    默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

属性：

    id：给对象在容器中提供一个唯一标识。用于获取对象。

    class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。

    scope：指定对象的作用范围。

         * singleton  :默认值，单例的.

         * prototype  :多例的.

         * request    :WEB项目中,Spring创建一个Bean的对象,将对象存入到request域中.

         * session    :WEB项目中,Spring创建一个Bean的对象,将对象存入到session域中.

         * global session :WEB项目中,应用在Portlet环境.如果没有Portlet环境那么globalSession相当于session.

    init-method：指定类中的初始化方法名称。

    destroy-method：指定类中销毁方法名称

    在AccountServiceImpl总加上2个方法

//初始化时调用

public void init(){

    System.out.println("AccountServiceImpl初始化了。。。。。");

}

//销毁时调用

public void destroy(){

    System.out.println("AccountServiceImpl销毁了。。。。。");

}

单例对象：scope="singleton"

    一个应用只有一个对象的实例。它的作用范围就是整个引用。

    生命周期：

       对象出生：当应用加载，创建容器时，对象就被创建了。

       对象活着：只要容器在，对象一直活着。

       对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

<bean id="accountService" class="com.oppo.service.impl.AccountServiceImpl" scope="singleton" init-method="init" destroy-method="destroy"></bean>

多例对象：scope="prototype"

    每次访问对象时，都会重新创建对象实例。

    生命周期：

       对象出生：当使用对象时，创建新的对象实例。

       对象活着：只要对象在使用中，就一直活着。

       对象死亡：当对象长时间不用时，被java的垃圾回收器回收了。

<bean id="accountService" class="com.oppo.service.impl.AccountServiceImpl" scope="prototype"  init-method="init" destroy-method="destroy"></bean>

实例化Bean 的方法

第一种方式：使用默认无参构造函数

    <!--在默认情况下：

       它会根据默认无参构造函数来创建类对象。如果bean中没有默认无参构造函数，将会创建失败。

    -->

<bean id="accountService" class="com.oppo.service.impl.AccountServiceImpl"/>

第二种方式：spring管理静态工厂-使用静态工厂的方法创建对象

/**

* 模拟一个静态工厂，创建业务层实现类

*/

public class StaticFactory {    

    public static AccountService createAccountService(){

       return new AccountServiceImpl();

    }

}

<!-- 此种方式是:

     使用StaticFactory类中的静态方法createAccountService创建对象，并存入spring容器

     id属性：指定bean的id，用于从容器中获取

     class属性：指定静态工厂的全限定类名

     factory-method属性：指定生产对象的静态方法

-->

<bean id="accountService"

      class="com.oppo.factory.StaticFactory"

      factory-method="createAccountService"></bean>

第三种方式：spring管理实例工厂-使用实例工厂的方法创建对象

/**

* 模拟一个实例工厂，创建业务层实现类

* 此工厂创建对象，必须现有工厂实例对象，再调用方法

*/

public class InstanceFactory {  

    public AccountService createAccountService(){

       return new AccountServiceImpl();

    }

}

<!-- 此种方式是：

     先把工厂的创建交给spring来管理。

    然后在使用工厂的bean来调用里面的方法

    factory-bean属性：用于指定实例工厂bean的id。

    factory-method属性：用于指定实例工厂中创建对象的方法。

-->

<bean id="instancFactory" class="com.oppo.factory.InstanceFactory"></bean>

<bean id="accountService"

      factory-bean="instancFactory"

      factory-method="createAccountService"></bean>

spring 依赖注入

    顾名思义，就是使用类中的构造函数，给成员变量赋值。注意，赋值的操作不是我们自己做的，而是通过配置的方式，让spring框架来为我们注入。具体代码如下：

/**

*/

public class AccountServiceImpl implements AccountService {

    private String name;

    private Integer age;

    private Date birthday;

    public AccountServiceImpl(String name, Integer age, Date birthday) {

       this.name = name;

       this.age = age;

       this.birthday = birthday;

    }

    @Override

    public void saveAccount() {

       System.out.println(name+","+age+","+birthday);    

    }

}

<!-- 使用构造函数的方式，给service中的属性传值

    要求：

       类中需要提供一个对应参数列表的构造函数。

    涉及的标签：

       constructor-arg

         属性：

          index:指定参数在构造函数参数列表的索引位置

          type:指定参数在构造函数中的数据类型

          name:指定参数在构造函数中的名称  ,用这个找给谁赋值

          =======上面三个都是找给谁赋值，下面两个指的是赋什么值的==============

          value:它能赋的值是基本数据类型和String类型

          ref:它能赋的值是其他bean类型，也就是说，必须得是在配置文件中配置过的bean

-->

<!--定义初始化一个Date的Bean-->

<bean id="date" class="java.util.Date"></bean>

name方式：

<bean id="accountService" class="com.oppo.service.impl.AccountServiceImpl">

    <constructor-arg name="name" value="张三"></constructor-arg>

    <constructor-arg name="age" value="18"></constructor-arg>

    <constructor-arg name="birthday" ref="date"></constructor-arg>

</bean>

type方式：

<bean id="accountService" class="com.oppo.service.impl.AccountServiceImpl">

  <constructor-arg type="java.lang.String" value="张三" />

  <constructor-arg type="java.lang.Integer" value="20" />

  <constructor-arg type="java.util.Date" ref="date" />

</bean>

index方式：

<bean id="accountService" class="com.oppo.service.impl.AccountServiceImpl">

   <constructor-arg index="0" value="张三" />

   <constructor-arg index="1" value="20" />

   <constructor-arg index="2" ref="date" />

</bean>

顾名思义，就是在类中提供需要注入成员的set方法。具体代码如下：

/** */

public class AccountServiceImpl implements AccountService {

    private String name;

    private Integer age;

    private Date birthday;

    public void setName(String name) {

       this.name = name;

    }

    public void setAge(Integer age) {

       this.age = age;

    }

    public void setBirthday(Date birthday) {

       this.birthday = birthday;

    }

    @Override

    public void saveAccount() {

       System.out.println(name+","+age+","+birthday);    

    }

}

<!-- 通过配置文件给bean中的属性传值：使用set方法的方式

    涉及的标签：

       property

       属性：

         name：找的是类中set方法后面的部分

         ref：给属性赋值是其他bean类型的

         value：给属性赋值是基本数据类型和string类型的

    实际开发中，此种方式用的较多。

-->

<bean id="accountService" class="com.oppo.service.impl.AccountServiceImpl">

       <property name="name" value="test"></property>

       <property name="age" value="21"></property>

       <property name="birthday" ref="date"></property>

</bean>

<bean id="date" class="java.util.Date"></bean>

注入集合属性

<!-- 注入集合数据

     List结构的：

       array,list,set

    Map结构的

       map,entry,props,prop

-->

<bean id="accountService" class="com.oppo.service.impl.AccountServiceImpl">

    <!-- 在注入集合数据时，只要结构相同，标签可以互换 -->

    <!-- 给数组注入数据 -->

    <property name="myStrs">

       <set>

         <value>AAA</value>

         <value>BBB</value>

         <value>CCC</value>

       </set>

    </property>

    <!-- 注入list集合数据 -->

    <property name="myList">

       <array>

         <value>AAA</value>

         <value>BBB</value>

         <value>CCC</value>

       </array>

    </property>

    <!-- 注入set集合数据 -->

    <property name="mySet">

       <list>

         <value>AAA</value>

         <value>BBB</value>

         <value>CCC</value>

       </list>

    </property>

    <!-- 注入Map数据 -->

    <property name="myMap">

       <props>

         <prop key="testA">aaa</prop>

         <prop key="testB">bbb</prop>

       </props>

    </property>

    <!-- 注入properties数据 -->

    <property name="myProps">

       <map>

         <entry key="testA" value="aaa"></entry>

         <entry key="testB">

          <value>bbb</value>

         </entry>

       </map>

    </property>

</bean>