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声明式事务

原文地址：https://www.cnblogs.com/eggTwo/p/11822343.html

时间： 2024-08-24 14:02:34

java web开发入门四（spring）基于intellig idea的相关文章

java web开发入门六（spring mvc）基于intellig idea

spring mvc ssm=spring mvc+spring +mybatis spring mvc工作流程 1A)客户端发出http请求,只要请求形式符合web.xml文件中配置的*.action的话,就由DispatcherServlet来处理. 1B)DispatcherServlet再将http请求委托给映射器的对象来将http请求交给对应的Action来处理 2)映射器根据客户的http请求,再对比<bean name="/hello.action如果匹配正确,再将http请

java web开发入门一（servlet和jsp）基于eclispe

servlet 用java语言开发动态资源网站的技术,在doGet方法中拼接显示html,在doPost方法中提交数据.类似于.net的ashx技术. servlet生成的class文件存放在tomcat中webapps目录下. 1.开发一个servlet步骤: 1)在src下新建包并编写java类,继承HttpServlet类 2)重写doGet和doPost方法 package com.eggtwo.boss; import java.io.IOException; import javax

Java开发工程师(Web方向) - 01.Java Web开发入门 - 第4章.Maven

第4章--Maven Maven实战 Java Web应用的部署: 手动式: 编译:javac -cp $CATALINA_HOME/lib/servlet-api.jar web-inf/classes/package/NoodlesServlet.java 打包:jar cvf Restaurant.war . 移动:mv Restaurant.war .../webapps/ 项目复杂时:比如项目文件很多 -- IDE如eclipse --> IDE式:(如eclipse) 下载第三方依赖

java web开发入门十（idea创建maven SSM项目）基于intellig idea

一.搭建项目骨架 二.配置pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apa

java web开发入门十二（idea创建maven SSM项目需要解决的问题）基于intellig idea（2019-11-09 11:23）

一.spring mvc action返回string带双引号问题 解决方法: 在springmvc.xml中添加字符串解析器 <!-- 注册string和json解析适配器 --> <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"> <property name="messageConverters"&

java web开发入门七（mybatis）基于intellig idea

mybatis 一. 入门开发步骤 1.导入相关jar包 mybatis3.4.2核心开发包 asm-5.1.jarcglib-3.2.4.jarcommons-logging-1.1.3.jarlog4j-1.2.17.jarmybatis-3.4.2.jar mysql驱动包 mysql-connector-java-5.1.7-bin.jar 2.定义实体及实体映射文件 定义member实体 package com.eggtwo.entity; import java.math.BigDe

java web开发入门八（ssm整合）基于intellig idea

ssm整合 一.导入相关包 二.开发流程 1.写entity package com.eggtwo.euq.entity; import java.io.Serializable; import java.math.BigDecimal; import java.util.Date; public class Member { private int id; public int getId() { return id; } public void setId(int id) { this.id

java web开发入门五（ssh整合）基于intellig idea

SSH整合 1.引入jar包 Struts 核心jar Hibernate 核心jar Spring Core  核心功能 Web  对web模块支持 Aop   aop支持 Orm   对hibernate支持 Jdbc/tx  jdbc支持包.事务相关包 2.配置xml *.hbm.xml <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE hibernate-mapping PUBLIC &qu

java web开发入门九（Maven使用&amp;idea创建maven项目）基于intellig idea

Maven 1.解决的问题 jar包的依赖和管理:版本.依赖关系等 自动构建项目 2.maven介绍 1.Maven是什么? Apache Maven是一个软件项目管理的综合工具.基于项目对象模型(POM)的概念,提供了帮助管理构建.文档.报告.依赖.发布等方法,Maven简化和标准化项目建设过程.处理编译,分配,文档,团队协作和其他任务的无缝连接. Maven增加可重用性并负责建立相关的任务. 2.Maven好处 可以将项目过程规范化.自动化.高效化以及强大的可扩展性,利用maven自身及其插