MyBatisSpring快速入门

 

时间:2017-1-29 02:15

 

Spring的IOC
Spring的AOP,AspectJ
Spring的事务管理,三颇框架的结合

——什么是Spring

1、Spring是分支的JavaSE/EE full-stack(一站式)轻量级开源框架。
    1)分层:
        * 
 SUN公司供的EE的老三交汇构造:Web层、业务层、数据访问层(持久层)
        *   Struts2凡是Web层基于MVC设计模式框架。
        *   Hibernate是持久层的一个ORM框架。
    2)一站式
        *   Spring框架对上述三交汇的每一样重叠还出化解方案:
            >   Web层:Spring MVC
            >   持久层:JDBC Template
            >   业务层:Spring的Bean管理

2、官网:http://www.springsource.org

3、Spring的面世是为替代EJB的层、低效、脱离现实。
    1)EJB
        SUN公司提出的EE解决方案
    2)推荐书籍:
        *   Expert One-to-One J2EE Design and Development
        *   Expert One-to-One J2EE Development without EJB

4、Spring的版本
    3.x和4.x
    Spring4亟待整合Hibernate4

——Spring核心

1、IoC
    1)控制反转:
        *   Inverse of Control反转控制
        *   将对象的始建权及由Spring完成。

   
2)在最初开发中,需要以Web层注入Service层的对象,需要在Service层注入Dao层的目标,这样做耦合度太强,不容易扩展。后来面世了面向接口编程方式,增强了而扩展性,但是将程序的切切实实贯彻编写到程序中晚,如果急需切换底层的贯彻,需要修改源代码,耦合性依然十分高。
        Java中生一个尺度:OCP原则,open –
close,扩展功能时尽可能不要修改源代码,而是提供新的章程属性的花样扩大其力量,所以出现了工厂模式,对切实对象的创导进行了扩大。
       
出现了厂模式后,把原来程序及落实类似的耦合转成了次和工厂的耦合,如果改动实现类似,则还是亟待改工厂类的源码,可以经安排文件的款式,在部署文件中改实现类似,在厂类吃经反射+配置文件的法门来得到一个类似的实例。

2、AOP
    Aspect Oriented Programming,面向切面编程。
   
是面向对象功能的延,不是替面向对象,而是用来化解OO中的一部分问题。

——Spring的优点

1、方便解耦,简化开发
   
Spring就是一个挺工厂,可以将有目标创建和仰关系之护卫交给Spring管理
2、AOP编程的支持
   
Spring提供面向切面编程,可以方便的实现对先后开展权力拦截、运行监控等功用。
3、声明式事务之支撑
    只需要经安排就可好对事物之管住,而任由需手动编程。
4、方便程序的测试
    Spring对Junit4支持,可以透过注解方便之测试Spring程序。
5、方便并各种可以框架
   
Spring不排外各种精美之开源框架,其中间提供了针对各种优质框架(如Struts2、Hibernate、MyBatis、Quartz等)的直接支持。
6、降低JavaEE API的应用难度
   
Spring对JavaEE开发中老难用的有些API(JDBC、JavaMail、远程调用等),都提供了包装,使这些API应用难度大大降低。

——Spring体系布局

Spring框架是一个分段架构,它涵盖一多元之效应因素并让分成大约20独模块。
这些模块分为Core Container、Data  Access/Integration、Web、AOP(Aspect
Oriented Programming)、Instrumentation和测试部分,如下图所示:

MyBatis 1

——Spring快速入门

1、下载Spring开发包
    1)spring-framework-3.2.0.RELEASE-dist.zip
        Spring开发包
        *   docs:Spring API和支出规范
        *   libs:Spring开发jar包
        *   schema:XML的律文件

    2)spring-framework-3.0.2.RELEASE-dependencies.zip
        Spring开发依赖包

2、创建一个Web工程

3、导入相应jar包
    Spring核心开发包:
        spring-beans-3.2.0.RELEASE.jar

        spring-context-3.2.0.RELEASE.jar

        spring-core-3.2.0.RELEASE.jar

        spring-expression-3.2.0.RELEASE.jar

 

    导入开发之日记记录包:
        com.springsource.org.apache.commons.logging-1.1.1.jar
        用于整合其他日志的管教(类似于Hibernate中之slf4j.jar)

    导入日志包:
        com.springsource.org.apache.log4j-1.2.15.jar

4、创建Spring的配备文件
    1)在src下创办一个applicationContext.xml配置文件。
    2)引入约束:
        找到xsd-config.html,引入beans的约束:

            <beans
xmlns=”http://www.springframework.org/schema/beans”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring
beans.xsd”>

            </beans>

    3)在约着安排HelloServiceImpl类
        <!– 通过bean标签来设置类的信息,通过id属性为接近起一个标识
–>

        <bean id=”userService”
class=”com.wyc.spring3.demo1.HelloServiceImpl”></bean>

5、示例代码:

    HelloService接口:

        /**

         * 入门案例

         */

        public interface HelloService {

            public void sayHello();

        }


    HelloServiceImpl实现类:

        /**

         * 入门案例的贯彻类似

         * 

         * @author WYC

         * 

         */

        public class HelloServiceImpl implements HelloService {

            public void sayHello() {

                System.out.println(“Hello 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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd”>

 

            <!– 通过bean标签来设置类的信息,通过id属性为接近起一个标识
–>

            <bean id=”userService”
class=”com.wyc.spring3.demo1.HelloServiceImpl”></bean>
 

        </beans>

 


    测试类:

        import org.junit.Test;

        import org.springframework.context.ApplicationContext;

        import
org.springframework.context.support.ClassPathXmlApplicationContext;

 

        public class SpringDemo1 {

            @Test

            /*

             * 传统艺术的开

             * 会造成程序的紧耦合

             */

            public void fun1(){

                HelloService helloService = new HelloServiceImpl();

                helloService.sayHello();

            }

 

            @Test

            /*

             * Spring中的支付

             */

            public void fun2(){

                /*

                 * 创建Spring的厂类来解析XML,获得配置文件中之类似

                 *
如果不写applicationContext.xml配置文件之门道,默认会到WEB-INF下去找

                 */

                ApplicationContext applicationContext = new
ClassPathXmlApplicationContext(“applicationContext.xml”);

 

                HelloService helloService = (HelloService)
applicationContext.getBean(“userService”);

                helloService.sayHello();

            }

        }
 

——IoC和DI的区别

IoC控制反转:说的凡创建对象实例的控制权从代码控制剥离至IOC容器控制,实际就是是若当xml文件决定,侧重于原理。

 

DI依赖注入:DependencyInjection
创建对象实例时,为这目标注入属性值或任何对象实例,侧重于实现。

    面向对象中目标中的干:
        *   依赖
            public class A {
                private B b;
                public void method(B b){
                }
            }
            A类依赖B类。
        *   继承
        *   聚合 

ioc是目的,di是一手。ioc是因让生成类的主意由传统方法(new)反过来,既程序员不调用new,需要类的时节是因为框架注入(di)。

——Spring框架加载配置文件

ApplicationContext应用达到下文,这是一个接口,用来加载Spring框架配置文件。

拖欠接口有点儿个落实类似:
    *   ClassPathXmlApplicationContext(“applicationContext.xml”);
        用于加载classpath下的安排文件(src下)
        示例代码:ApplicationContext applicationContext = new
ClassPathXmlApplicationContext(“applicationContext.xml”);

    *   FileSystemXmlApplicationContext(“applicationContext.xml”);
        用于加载磁盘下的布置文件
        示例代码:ApplicationContext applicationContext = new
FileSystemXmlApplicationContext(“G:\\MyEclipse Professional 2014
Projects\\Spring3_day01\\src\\com\\wyc\\spring3\\demo1/applicationContext.xml”);

——引入配置文件

当一个布局文件中之布局信息过多的动静下,可以采用多个布局文件,加载方法如下:
    1)ApplicationContext context = new
ClassPathXmlApplicationContext(“bean1.xml”, “bean2.xml”);
        可以同样不善加载多独布局文件。

    2)在苟加载的安排文件被引入其他安排文件:
        使用import标签<import
resource=”applicationContext2.xml”/>

——ApplicationContext和BeanFactory的区别

ApplicationContext类继承了BeanFactory。

BeanFactory采用推加载,第一次于调整用getBean()方法时才见面加载BeanFactory。
ApplicationContext类加载配置文件之时段,就会创造所有类。

ApplicationContext对BeanFactory提供了扩大:
    *   国际化处理
    *   事件传递
    *   Bean自动装配
    *   各种不同应用层的Context实现

头开发时,可以用BeanFactory来成功以上功能:

    /*

     * 使用BeanFactory完成操作

     */

    public void fun4(){

        BeanFactory bean = new XmlBeanFactory(new
ClassPathResource(“applicationContext.xml”));

        HelloService helloService = (HelloService)
bean.getBean(“userService”);

        helloService.sayHello();

    }

——MyEclipse配置XML提示(Schema约束)

window —— 搜索xml catalog —— add —— 找到Schema的职位 —— 选择URI ——
赋值约束中之URI —— 选择Schema location

——IoC如何实例化Bean

1、Spring框架创建Bean的点子:
    提供了三种方法实例化Bean:
        *   使用构造方法实例化(默认无参)
        *   使用静态工厂方法实例化(简单工厂模式)
        *   使用实例工厂方法实例化(工厂方法模式)


2、无参构造方法实例化

实体类:

public class Bean1 {

    public Bean1(){

        System.out.println(“Bean1无参构造方法被实践”);
    } 

}

测试方法:

public void fun1(){

    /*

     * 如果Bean1类中之无参构造方法不设有,则会丢掉来好

     */

    ApplicationContext context = new
ClassPathXmlApplicationContext(“applicationContext.xml”);

    Bean1 bean1 = (Bean1) context.getBean(“bean1”);

    System.out.println(bean1);

}

XML配置:

<!– 首先种办法:默认情况下下无参构造方法 –>

<bean id=”bean1″ class=”com.wyc.spring3.demo2.Bean1″></bean>

—————————————————————————————————————————- 

3、静态工厂实例化对象
    通过工厂的静态方法实例化对象。

实体类:

public class Bean2Factory {

    public static Bean2 getBean2(){

        System.out.println(“Bean2静态工厂给实践”);

        return new Bean2();

    }

}

测试方法:

public void fun2(){

    /*

     * 如果Bean1类中之无参构造方法不在,则会丢掉来深

     */

    ApplicationContext context = new
ClassPathXmlApplicationContext(“applicationContext.xml”);

    Bean2 bean2 = (Bean2) context.getBean(“bean2”);

    System.out.println(bean2);

}

XML配置:
<!– 次种方法:使用静态工厂实例化对象 –>

<bean id=”bean2″
class=”com.wyc.spring3.demo2.Bean2Factory” factory-method=”getBean2″></bean>
 

—————————————————————————————————————————- 

4、实例工厂实例化对象
    通过工厂类的实例来实例化对象。

实体类:

public class Bean3Factory {

    public Bean3 getBean3(){

        System.out.println(“Bean3实例工厂被执行”);

        return new Bean3();

    }

}

测试方法:

public void fun3(){

    /*

     * 如果Bean1类中之无参构造方法不存在,则会丢弃来老

     */

    ApplicationContext context = new
ClassPathXmlApplicationContext(“applicationContext.xml”);

    Bean3 bean3 = (Bean3) context.getBean(“bean3”);

    System.out.println(bean3);

}

XML配置:

<!– 第三种办法:使用实例工厂来实例化对象 –>

<bean
id=”bean3″ factory-bean=”bean3Factory” factory-method=”getBean3″></bean>

<bean id=”bean3Factory”
class=”com.wyc.spring3.demo2.Bean3Factory”></bean>

——Bean标签的任何安排

1、name和id的区别
    *  
id:遵守了XML中id的律,来确保属性是绝无仅有的:id唯一,并且不可知起特殊字符。

    *   name:name无要求

    如果bean标签及尚未配备id,那么name属性就足以用作id属性来取了。

2、类的作用域
    *   scope属性:
        >   singleton:(单例,是默认属性)
            在Spring IoC容器中只有存在一个Bean实例,Bean以单例方式在。
        >   prototype:(多例)
           
每次从容器中调用Bean时,都回来一个新的实例,即每次调用getBean()时,相当给履行new
XxxBean()。
        >  
request:(Web开发被,创建一个目标,将目标保存及request域中,调用request.setAttribute())
           
每次执行HTTP请求都见面创造一个初的Bean,该作用域仅适用于WebApplicationContext环境。
        >  
session:(Web开发被,床一个对象,将目标保存到session域中,调用session.setAttribute())
            同一个HTTP
Session共享一个Bean,不同Session使用不同之Bean,仅适用于WebApplicationContext环境。
        >   globalSession:
           
一般用来Porlet应用环境,该作用域仅适用于WebApplicationContext环境。
           
Porlet应用环境一般指分布式开发,只要登录一个网今后,其他系统都见面获用户信息。
            如果非是Prolet环境,则globalSession等同于Session。

    在其实的支付被,主要使用Singleton和Prototype。

3、示例代码
    验证单例与多例:

    配置信息:
        <bean id=”customer” class=”com.wyc.sprint3.demo3.Customer”
scope=”prototype”></bean>

    测试代码:

        public void fun1(){

            ApplicationContext context = new
ClassPathXmlApplicationContext(“applicationContext.xml”);

 

                Customer c1 = (Customer) context.getBean(“customer”);

 

                System.out.println(c1);

 

                /*

                 *
当scope的价值吗singleton时,两个目标是平之,当创建第二单对象时无会见还调用构造方法,而是直接拿走已在实例

                 *
当scope的值吗prototype时,会调用多次构造方法,创建多只实例

                 */

                Customer c2 = (Customer) context.getBean(“customer”);

                System.out.println(c2);

            }

——Spring容器中Bean的生命周期

Spring初始化Bean或销毁Bean时,有时要做一些处理工作,因此Spring可以当创建与销毁Bean的早晚调用Bean的有数个生命周期方法:
    <bean id=”bean” class=”…Bean” init-method=”setup”
destory-method=”shutdown” />

setup:
    当Bean被载入到容器的时光调用setup方法。

shutdown:
    当Bean从容器中删去的上调用shutdown方法。
    destory-method仅在scope=singleton时有效。
    销毁方法必须手动关闭容器(工厂)。

Bean生命周期的11独步骤:
    1)instantiate bean对象实例化(构造方法)
    2)populate properties封装属性(属性注入,set()方法)
    3)如果Bean实现BeanNameAware,则执行setBeanName
   
4)如果Bean实现beanFactoryAware或者ApplicationContextAware,则实行setBeanFactory或者设置上下文对象setApplicationContext。
   
5)如果在落实类BeanPostProcessor(后甩卖Bean),则实施postProcessBeforeInitialization。
    6)如果Bean实现InitializingBean,则执行afterPropertiesSet。
    7)调用<bean init-method=”init”>执行指定初始化方法:init。
   
8)如果在类似实现BeanPostProcessor(处理Bean),执行postProcessAfterInitialization。
    9)执行工作处理
    10)如果Bean实现DisposableBean,则执行destory方法。
    11)调用<bean destory-method=”destory”>,执行指定销毁方法。

示范代码:

CustomerService类实体类:

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.BeanFactory;

import org.springframework.beans.factory.BeanFactoryAware;

import org.springframework.beans.factory.BeanNameAware;

import org.springframework.beans.factory.DisposableBean;

import org.springframework.beans.factory.InitializingBean;

 

public class CustomerService implements BeanNameAware, BeanFactoryAware,
InitializingBean, DisposableBean {

 

    private String name;

 

    public void setName(String name) {

        System.out.println(“第二步:属性注入”);

        this.name = name;

    }

 

    public CustomerService(){

        System.out.println(“第一步:实例化Customer类”);

    }

 

    public void add(){

        System.out.println(“添加客户”);

    }

 

    public void find(){

        System.out.println(“查询客户”);

    }

 

    public void setBeanName(String name) {

        System.out.println(“第三步:实现BeanNameAware,注入配置的类似的称:”

  • name);

    }

 

    public void setBeanFactory(BeanFactory beanFactory) throws
BeansException {

        System.out.println(“第四步:实现BeanFactoryAware,注入applicationContext:”

  • beanFactory);

    }

 

    public void afterPropertiesSet() throws Exception {

        System.out.println(“第六步:设置完属性后实施的点子”);

    }

 

    public void init(){

        System.out.println(“第七步:执行打定义初始化方法”);

    }

 

    public void destory(){

        System.out.println(“第十一步:执行打定义销毁方法”);

    }

 

    public void destroy() throws Exception {

        System.out.println(“第十步:执行DisposableBean的destory方法”);

    }

}

——MyBeanPostProcessor后处理Bean

本着点名Bean的指定方法进行合并操作。

import org.springframework.beans.BeansException;

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

 

/**

 * 后拍卖Bean类必须配备到xml配置文件中,不待写id,因为凡由Spring容器自动调用的

 * @author WYC

 *

 */

public class MyBeanPostProcessor implements BeanPostProcessor{

 

    /**

     * bean:实例对象

     * beanName:配置文件被布局的切近的标识,id或者name

     */

    public Object postProcessBeforeInitialization(Object bean, String
beanName) throws BeansException {

        System.out.println(“第五步:初始化之前的操作”);

        return bean;

    }

 

    public Object postProcessAfterInitialization(Object bean, String
beanName) throws BeansException {

        System.out.println(“第八步:初始化结束晚底操作”);

        return bean;

    }

}


配备文件:

    <bean id=”customerService”
class=”com.wyc.spring3.demo4.CustomerService” init-method=”init”
destroy-method=”destory”>

        <property name=”name” value=”张三”></property>

    </bean>

 

    <!– 配置后处理Bean,不欲写id,因为凡由于Spring容器自动调用
–>

    <bean
class=”com.wyc.spring3.demo4.MyBeanPostProcessor”></bean>


测试类:

public class SpringDemo4 {

  @Test

  public void fun1(){

  ApplicationContext context = new
ClassPathXmlApplicationContext(“applicationContext.xml”);

  CustomerService customerService = (CustomerService)
context.getBean(“customerService”);

  customerService.add();

  customerService.find();

  ((ClassPathXmlApplicationContext)context).close();

  }

}


打印结果:

 

第一步:实例化Customer类

其次步:属性注入

其三步:实现BeanNameAware,注入配置的近乎的名:customerService

第四步:实现BeanFactoryAware,注入applicationContext:

第五步:初始化之前的操作

第六步:设置完属性后实施的法子

第七步:执行于定义初始化方法

第八步:初始化结束后底操作

补偿加客户

查询客户

第十步:执行DisposableBean的destory方法

第十一步:执行于定义销毁方法

==================================================================================

动用后甩卖Bean添加权限校验:

 

改上述代码:

    1)添加CustomerService接口
   
2)将原CustomerService类改吧CustomerServiceImpl类并促成CustomerService接口
    3)将配置文件修改为:
            <bean id=”customerService”
class=”com.wyc.spring3.demo4.CustomerServiceImpl” init-method=”init”
destroy-method=”destory”>

                <property name=”name”
value=”张三”></property>

            </bean>

 

            <!– 配置后处理Bean –>

            <bean
class=”com.wyc.spring3.demo4.MyBeanPostProcessor”></bean>

以身作则代码:

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

 

import org.springframework.beans.BeansException;

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

 

/**

 *
后处理Bean类必须安排到xml配置文件被,不需要写id,因为是由Spring容器自动调用的

 * @author WYC

 *

 */

public class MyBeanPostProcessor implements BeanPostProcessor{

 

    /**

     * bean:实例对象

     * beanName:配置文件被安排的类的标识,id或者name

     */

    public Object postProcessBeforeInitialization(Object bean, String
beanName) throws BeansException {

        System.out.println(“第五步:初始化之前的操作”);

        return bean;

    }

 

    public Object postProcessAfterInitialization(final Object bean,
String beanName) throws BeansException {

        System.out.println(“第八步:初始化结束后底操作”);

 

        /*

         * 验证权限操作

         */

 

        /*

         * 只对CustomerServiceImpl类进行权力验证

         */

        if(beanName.equals(“customerService”)){
            // 如果是CustomerServiceImpl类,则执行动态代理 

            Object proxy =
Proxy.newProxyInstance(bean.getClass().getClassLoader(),
bean.getClass().getInterfaces(), new InvocationHandler(){

 

                // 在调用目标措施时,都一定给调用invoke()方法

                public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable {

                    // 只对add方法上加校验,对add方法开展加强

                    String name = method.getName();

                    if(name.equals(“add”)){

                        System.out.println(“执行权验证操作”);

                        Object result = method.invoke(bean, args);

                        return result;

                    } 

                    // 如果无是add方法,则未开展加强

                    return method.invoke(bean, args);

                }

            });

            return proxy;

        }

 

        return bean;

    }

}

——总结

1、Spring的概述

2、Spring环境的搭建

3、Spring中的IoC

3、IoC和DI的区别
    *   IoC:控制反转,将对象的创建权交给Spring
    *  
DI:依赖注入,DI需要出IoC的条件,在创建对象的时段,DI将对象的依属性一连流入及接近中。

4、Bean的生命周期
    *   后处理Bean:BeanPostProcessor类

网站地图xml地图