java web开发入门四(spring)基于intellig idea

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java web开发入门四(spring)基于intellig idea相关的知识,希望对你有一定的参考价值。

spring

 

 1.spring简介

Spring框架,可以解决对象创建以及对象之间依赖关系的一种框架。

                          且可以和其他框架一起使用;Spring与Struts,  Spring与hibernate

                          (起到整合(粘合)作用的一个框架)

Spring提供了一站式解决方案:

         1) Spring Core  spring的核心功能: IOC容器, 解决对象创建及依赖关系

         2) Spring Web  Spring对web模块的支持。

                                                     -à 可以与struts整合,让struts的action创建交给spring

                                                -à spring mvc模式

         3) Spring DAO  Spring 对jdbc操作的支持  【JdbcTemplate模板工具类】

         4) Spring ORM  spring对orm的支持:

                                                     à 既可以与hibernate整合,【session】

                                                     à 也可以使用spring的对hibernate操作的封装

         5)Spring AOP  切面编程

         6)SpringEE   spring 对javaEE其他模块的支持

 

2.spring开发步骤

1.下载引用开发包

spring各个版本中:

         在3.0以下的版本,源码有spring中相关的所有包【spring功能 + 依赖包】

                  如2.5版本;

         在3.0以上的版本,源码中只有spring的核心功能包【没有依赖包】

                  (如果要用依赖包,需要单独下载!) 

源码, jar文件:spring-framework-3.2.5.RELEASE

commons-logging-1.1.3.jar                  日志

spring-beans-3.2.5.RELEASE.jar        bean节点

spring-context-3.2.5.RELEASE.jar       spring上下文节点

spring-core-3.2.5.RELEASE.jar         spring核心功能

spring-expression-3.2.5.RELEASE.jar    spring表达式相关表 

以上是必须引入的5个jar文件!

2.在src下面的包中创建Student对象:

package com.eggtwo.test;

public class Student {
    private int age;
    private String name;
public Student(){
    super();
    System.out.println("调用了student的构造函数");
}
    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void init_student()
    {
        System.out.println("初始化了对象");
    }
    public void destroy_student()
    {
        System.out.println("销毁了对象");
    }
}

 

3.在src下面的包中引入核心配置文件: applicationContext.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!--
      1) 对象创建: 单例/多例
          scope="singleton", 默认值, 即 默认是单例    【service/dao/工具类】
       scope="prototype", 多例;                 【Action对象】
      2) 什么时候创建?
            scope="prototype"  在用到对象的时候,才创建对象。
         scope="singleton"  在启动(容器初始化之前), 就已经创建了bean,且整个应用只有一个。
      3)是否延迟创建
            lazy-init="false"  默认为false,  不延迟创建,即在启动时候就创建对象
            lazy-init="true"   延迟初始化, 在用到对象的时候才创建对象(只对单例有效)
      4) 创建对象之后,初始化/销毁
            init-method="init_student"       【对应对象的init_student方法,在对象创建爱之后执行 】
         destroy-method="destroy_student"  【在调用容器对象的destriy方法时候执行,(容器用实现类)】

-->
    <bean id="student" class="com.eggtwo.test.Student" scope="prototype" lazy-init="false"  init-method="init_student"  destroy-method="destroy_student"></bean>

</beans>

4.使用pring创建对象:getBean中的参数是xml中设置的id

package com.eggtwo.test;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class APPTest {
    @Test
    public  void  test(){
        // 得到IOC容器对象  【用实现类,因为要调用销毁的方法】
        System.out.println("-----容器创建前-----");
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("com/eggtwo/test/applicationContext.xml");
        System.out.println("-----容器创建完成-----");

        // 从容器中获取bean
        Student student1 = (Student) ac.getBean("student");
        Student student2 = (Student) ac.getBean("student");

        System.out.println(student1);
        System.out.println(student2);

        // 销毁容器对象
        ac.destroy();
    }
}

 

2.spring IOC容器的配置

1.对象的创建方式

SpringIOC容器,是spring核心内容。

作用: 创建对象 & 处理对象的依赖关系 

IOC容器创建对象:

创建对象, 有几种方式:

1) 调用无参数构造器

2) 带参数构造器

3) 工厂创建对象

                  工厂类,静态方法创建对象

                  工厂类,非静态方法创建对象

<!-- ###############对象创建############### -->
    
    <!-- 1. 默认无参数构造器 
    <bean id="user1" class="cn.itcast.b_create_obj.User"></bean>
    -->
    
    <!-- 2. 带参数构造器 -->
    <bean id="user2" class="cn.itcast.b_create_obj.User">
        <constructor-arg index="0" type="int" value="100"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>
    </bean>
    
    <!-- 定义一个字符串,值是"Jack" ;  String s = new String("jack")-->
    <bean id="str" class="java.lang.String">
        <constructor-arg value="Jacks"></constructor-arg>
    </bean>
    <bean id="user3" class="cn.itcast.b_create_obj.User">
        <constructor-arg index="0" type="int" value="100"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg>
    </bean>
    
    
    <!-- 3. 工厂类创建对象 -->
    <!-- # 3.1 工厂类,实例方法 -->
    <!-- 先创建工厂 -->
    <bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean>
    <!-- 在创建user对象,用factory方的实例方法 -->
    <bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>
    
    
    <!-- # 3.2 工厂类: 静态方法 -->
    <!-- 
        class 指定的就是工厂类型
        factory-method  一定是工厂里面的“静态方法”
     -->
    <bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>

 

 

2.对象的依赖关系

Spring中,如何给对象的属性赋值?  【DI, 依赖注入】

         1) 通过构造函数

         2) 通过set方法给属性注入值

         3) p名称空间

         4)自动装配(了解)

         5) 注解

    <bean id="userDao" class="com.eggtwo.dao.UserDao" ></bean>
    <bean id="userService" class="com.eggtwo.service.UserService">
        <property name="userDao" ref="userDao"></property>
    </bean>
    <bean id="userAction" class="com.eggtwo.action.UserAction">
        <property name="userService" ref="userService"></property>
    </bean>

 

3.spring和strut结合

步骤:

引入jar文件

         1)引入struts .jar相关文件

         2)spring-core  相关jar文件

         3)spring-web 支持jar包

                  spring-web-3.2.5.RELEASE.jar                         【Spring源码】

            struts2-spring-plugin-2.3.4.1.jar      【Struts源码】

 

配置:

4)配置XML

web.xml   

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!-- 引入struts核心过滤器 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- 2. spring 配置 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/classes/bean-*.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>


</web-app>

bean.xml              【spring ioc容器配置】

每个包配置一个bean

 

 

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


    <bean id="userService" class="com.eggtwo.service.UserService">
        <property name="userDao" ref="userDao"></property>
    </bean>

</beans>

 

struts.xml    struts路径与action映射配置】

注意:action交给了spring创建,不再是tomcat创建

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
          "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
          "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
    <!-- name任意名称,extends:继承的类 -->
    <package name="com.eggtwo.action" namespace="/" extends="struts-default" abstract="false">


        <action name="execute" class="userAction" method="execute">
            <!-- name:返回值, 跳转地址 -->
            <result name="success" >/index.jsp</result>
        </action>

    </package>
</struts>

 

                

【核心过滤器: 引入struts功能】

【初始化spring的ioc容器】

 

4.代理模式

静态代理(JDK代理)

动态代理(JDK代理)

CgLib代理

 

5.Spring 注解实现AOP编程

AOP的实现本质上是代理(动态代理和Cglib代理)

注意:java jdk使用1.8版本,spring的jar包要使用4.2版本以上才可以使用AOP功能

开发步骤:

1.引入aop相关jar包

spring-aop-3.2.5.RELEASE.jar   [spring3.2.5源码/libs]

aopalliance.jar   [spring-framework-2.5.6/lib/aopalliance]

aspectjrt.jar       [aspectj-1.8.2/lib]

aspectjweaver.jar   [aspectj-1.8.2/lib]

2.bean.xml中引入aop名称空间

 

 

 3.在bean.xml中开启AOP注解模式

 

 

 4.新建切面类

package com.eggtwo.aopanno;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component //注解 ioc
@Aspect   //指定当前类为切面类
public class MyAspect {

    @Pointcut("execution(* com.eggtwo.aopanno.UserDao.*(..))")
    public void myPointcut() {
    }

    //执行方法前执行
    @Before("myPointcut()")
    public void begin() {
        System.out.println("开始执行");
    }

    //执行目标方法后执行:(无论目标方法是否出现异常,都会执行)
    @After("myPointcut()")
    public void end() {
        System.out.println("结束执行");
    }

    //执行目标方法后执行:(发生异常不执行)
    @AfterReturning("myPointcut()")
    public void afterReturning() {
        System.out.println("afterReturning");
    }

    //执行目标方法后执行:(发生异常执行)
    @AfterThrowing("myPointcut()")
    public void afterThrowing() {
        System.out.println("afterThrowing");
    }
    //环绕通知:环绕目标方法执行
    @Around("myPointcut()")
    public void around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前");
        pjp.proceed();
        System.out.println("环绕后");

    }
}

执行结果顺序:

 

 

 

5.测试

package com.eggtwo.aopanno;

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

public class TestApp {
    @Test
    public void test() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("com/eggtwo/aopanno/bean.xml");
        UserDao userDao = (UserDao) ac.getBean("userDao");
        System.out.println(userDao.getClass());
        userDao.save();
    }
}

 

 

6.Spring XML实现AOP编程

1.引入jar相关开发包(同步骤5.1)

 2.引入命名空间(同5.2)

3.aop配置:添加切面类

package com.eggtwo.aopxml;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

public class MyAspect {


    //执行方法前执行
    public void begin() {
        System.out.println("开始执行");
    }

    //执行目标方法后执行:(无论目标方法是否出现异常,都会执行)
    public void end() {
        System.out.println("结束执行");
    }

    //执行目标方法后执行:(发生异常不执行)
    public void afterReturning() {
        System.out.println("afterReturning");
    }

    //执行目标方法后执行:(发生异常执行)
    public void afterThrowing() {
        System.out.println("afterThrowing");
    }

    //环绕通知:环绕目标方法执行
    public void around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前");
        pjp.proceed();
        System.out.println("环绕后");

    }
}

4.配置bean.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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
">
    <!--spring IOC-->
    <bean id="userDao" class="com.eggtwo.aopxml.UserDao"></bean>
    <bean id="myAspect" class="com.eggtwo.aopxml.MyAspect"></bean>


    <!--AOP配置-->
    <aop:config>
        <!-- 定义切面点表达式:指定拦截的方法       -->
        <aop:pointcut id="myPointcut" expression="execution(* com.eggtwo.aopxml.UserDao.*(..))"/>
        <!-- 切面:引用上面配置的切面类-->
        <aop:aspect ref="myAspect">
            <!--<aop:before method="begin" pointcut="execution(* com.eggtwo.aopxml.UserDao.*(..))"/>-->
            <aop:before method="begin" pointcut-ref="myPointcut"/>
            <aop:before method="end" pointcut-ref="myPointcut"/>
        </aop:aspect>
    </aop:config>
</beans>

 

7.Spring 切入点表达式

作用:指定拦截的方法

 

8.Spring 事务管理

事务的实现本身是AOP

XML方式实现spring声明式事务

以上是关于java web开发入门四(spring)基于intellig idea的主要内容,如果未能解决你的问题,请参考以下文章

Spring入门

Spring MVC入门

Spring MVC入门知识总结

Spring MVC入门讲解

Spring Boot 2从入门到入坟 | Web场景开发篇:超硬核两万四千多字,全网最详细源码分析之静态资源配置原理,不是你来砍我

Java之Spring AOP入门到精通IDEA版(一篇文章精通系列)