Spring框架知识点（二）

最新推荐文章于 2022-08-13 01:20:15 发布

高风言

最新推荐文章于 2022-08-13 01:20:15 发布

阅读量151

点赞数

分类专栏： java框架文章标签： spring aop log4j struts2 spring框架注解

本文链接：https://blog.csdn.net/gaofengyan/article/details/83348088

版权

java框架专栏收录该内容

18 篇文章 0 订阅

订阅专栏

目录：
1.spring的bean管理（注解）
（1）使用注解创建对象
（2）使用注解注入属性
（3）Xml和注解方式混合使用
2.AOP
（1）Aop概述
（2）Aop底层原理
（3）Aop操作相关术语
3.spring的aop操作（基于aspectj的xml方式）
4.Log4j介绍
5.Spring整合web项目演示

1.spring的bean管理（注解）

注解介绍
1.代码里面特殊标记，使用注解可以完成功能
2.注解写法 @注解名称（属性名称=属性值）
3.注解使用在类上面，方法上面和属性上面

Spring注解开发准备

1 导入jar包
（1）导入基本的jar包
在这里插入图片描述
2 创建类，创建方法
3 创建spring配置文件，引入约束
（1）除了ioc基本操作引入的beans约束
（2）做spring的ioc注解开发，还需要引入新的约束

4 开启注解的扫描

<!--开启注解扫描 （1）到包里面扫描类、方法、属性上面是否有注解-->
	<context:component-scan base-package="cn.itcast.anno"></context:component-scan>
    
    <!--只扫描属性上面的注解  -->
    <context:annotation-config></context:annotation-config>

注解创建对象

1 在创建对象的类上面使用注解实现
在这里插入图片描述
具体操作实例：
类User.java

package cn.itcast.anno;

import org.springframework.stereotype.Component;

@Component(value="user") //<bean id="user" class=""/>
public class User {
	public void add() {
		System.out.println("add...........");
	}
}

配置文件bean1.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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
	
	<!--开启注解扫描 （1）到包里面扫描类、方法、属性上面是否有注解-->
	<context:component-scan base-package="cn.itcast.anno"></context:component-scan>
    
    <!--只扫描属性上面的注解  -->
    <context:annotation-config></context:annotation-config>

</beans>

测试TestAnno.java

package spring_day02;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.itcast.anno.User;

public class TestAnno {

	@Test
	public void test1() {
		ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
		User user = (User) context.getBean("user");
		System.out.println(user);
		user.add();
	}
}

测试结果：

log4j:WARN No appenders could be found for logger (org.springframework.core.env.StandardEnvironment).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
cn.itcast.anno.User@1dd92fe2
add...........

2 创建对象有四个注解
在这里插入图片描述
（1）@Component
（2）@Controller
（3）@Service
（4）@Repository
目前这四个注解功能是一样的，都是创建对象。
3 创建对象是单实例还是多实例

注解注入属性
1 创建UserService类，创建UserDao类，在UserService得到UserDao对象
（1）注入属性第一个注解@Autowired
（2）注入属性的第二个注解@Resource(name=“dao”)name属性值写的是注解创建dao对象的value值
具体实现过程:
UserDao.java

package cn.itcast.anno;

import org.springframework.stereotype.Component;

@Component(value="dao")
public class UserDao {

	public void add(){
		System.out.println("dao.......");
	}
}

UserService.java

package cn.itcast.anno;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service(value = "userService")
public class UserService {

	// 得到dao对象
	// 1 定义dao类型属性
	// 在dao属性上面使用注解 完成对象注入
	@Autowired
	private UserDao userDao;

	// 使用注解方式时候不需要set方法
	public void add() {
		System.out.println("service.....");
		userDao.add();
	}
}

测试

@Test
	public void test2() {
		ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
		UserService userService = (UserService) context.getBean("userService");
		userService.add(); 
	}

结果

log4j:WARN No appenders could be found for logger (org.springframework.core.env.StandardEnvironment).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
service.....
dao.......

配置文件和注解混合使用
1.创建对象操作使用配置文件方式实现
在这里插入图片描述
2.注入属性的操作使用注解方式实现

AOP概念

1.Aop：面向切面（方面）编程，扩展功能不修改源代码实现
2.Aop采用横向抽取机制，取代了传统的纵向继承体系重复性代码

AOP原理

纵向机制
在这里插入图片描述
横向机制

AOP操作术语
切面（Aspect）： 一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。在Spring AOP中，切面可以使用基于模式或者基于@Aspect注解的方式来实现。是切入点和通知（引介）的结合。
通知（Advice）： 在切面的某个特定的连接点上执行的动作。其中包括了“around”、“before”和“after”等不同类型的通知（通知的类型将在后面部分进行讨论）。许多AOP框架（包括Spring）都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。所谓通知是指拦截到Joinpoint之后所要做的事情就是通知，通知分为前置通知，后置通知，异常通知，最终通知，环绕通知（切面要完成的功能）。
切入点（Pointcut）： 匹配连接点的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。所谓切入点是指我们要对哪些Joinpoint进行拦截的定义。
连接点（Joinpoint）： 在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在Spring AOP中，一个连接点总是表示一个方法的执行。类里面可以被增强的方法，这些方法成为连接点。
引入（Introduction）： 用来给一个类型声明额外的方法或属性（也被称为连接类型声明（inter-type declaration））。Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，你可以使用引入来使一个bean实现IsModified接口，以便简化缓存机制。引介是一种特殊的通知，在不修改类代码的前提下，Introduction可以在运行期为类动态的添加一些方法或Field。
目标对象（Target Object）： 被一个或者多个切面所通知的对象。也被称做被通知（advised）对象。既然Spring AOP是通过运行时代理实现的，这个对象永远是一个被代理（proxied）对象。代理的目标对象（要增强的类）。
AOP代理（AOP Proxy）： AOP框架创建的对象，用来实现切面契约（例如通知方法执行等等）。在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。一个类被AOP织入增强后，就产生一个结果代理类。
织入（Weaving）： 把切面连接到其它的应用程序类型或者对象上，并创建一个被通知的对象。这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。是把增强应用到目标的过程，把advice应用到target的过程。
在这里插入图片描述

通知类型

前置通知（Before advice）
在某连接点之前执行的通知，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）。
后置通知（After returning advice）
在某连接点正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。
异常通知（After throwing advice）
在方法抛出异常退出时执行的通知。
最终通知（After (finally) advice）
当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
环绕通知（Around Advice）
包围一个连接点的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它自己的返回值或抛出异常来结束执行。
环绕通知是最常用的通知类型。和AspectJ一样，Spring提供所有类型的通知，推荐使用尽可能简单的通知类型来实现需要的功能。例如，如果你只是需要一个方法的返回值来更新缓存，最好使用后置通知而不是环绕通知，尽管环绕通知也能完成同样的事情。用最合适的通知类型可以使得编程模型变得简单，并且能够避免很多潜在的错误。比如，你不需要在JoinPoint上调用用于环绕通知的proceed()方法，就不会有调用的问题。
引用原文：https://blog.csdn.net/wangyongxia921/article/details/46627379

Spring的aop操作联合aspectj框架

1.在spring里面进行aop操作，使用aspectj
（1）aspectj不是spring一部分，和spring一起使用进行aop操作
（2）Spring2.0以后新增了对AspectJ支持
2.使用aspectj实现aop有两种方式
（1）基于aspectj的xml配置
（2）基于aspectj的注解方式
AOP操作准备
1.除了导入基本的jar包外，还需要导入aop相关的jar包
在这里插入图片描述
2.创建spring核心配置文件，导入aop的约束

使用表达式配置切入点
1.切入点：实际增强的方法
2.常用的表达式
execution（<访问修饰符>?<返回类型><方法名>(<参数>)<异常>）
（1）execution（cn.itcast.aop.Book.add(…)）第一个代表任何访问修饰都行
（2）execution（cn.itcast.aop.Book.(…)）指定类中任何访问修饰符的所有方法
(3) execution（* .(…)）表示对所有类的所有方法进行增强
（4）execution（save（…））匹配所有save开头的方法
基于Aspectj的aop操作
在这里插入图片描述
使用表达式配置增强通知实例
Book.java

package cn.itcast.aop;

//被增强的类
public class Book {

	public void add() {
		System.out.println("add.....");
	}
}

MyBook.java

package cn.itcast.aop;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyBook {

	public void before1() {
		System.out.println("前置增强........");
	}
	
	public void after1(){
		System.out.println("后置增强.........");
	}
	
	//环绕通知
	public void around1(ProceedingJoinPoint pj) throws Throwable{
		//方法之前
		System.out.println("方法之前............");
		
		//执行被增强的方法
		pj.proceed();
		
		//方法之后
		System.out.println("方法之后............");
	}
}

配置文件

<?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:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
	<!--1.配置对象 -->
	<bean id="book" class="cn.itcast.aop.Book"></bean>
	<bean id="myBook" class="cn.itcast.aop.MyBook"></bean>
	<!--2.配置aop操作 -->
	<aop:config>
		<!--2.1 配置切入点 -->
		<!--注意点：配置中的第一个星号（*）代表数据类型，因此中间需要一个空格 -->
		<aop:pointcut expression="execution(* cn.itcast.aop.*.*(..))"
			id="pointcut1" />

		<!--2.2 配置切面 把增强用到方法上面 -->
		<!--ref 写增强类对象 -->
		<aop:aspect ref="myBook">
			<!--配置增强的类型 method:增强类中使用哪个方法作为前置 -->
			<aop:before method="before1" pointcut-ref="pointcut1" />
			<!--配置后置增强(后置通知) -->
			<aop:after-returning method="after1"
				pointcut-ref="pointcut1" />
			<!--配置环绕增强 -->
			<aop:around method="around1" pointcut-ref="pointcut1" />
		</aop:aspect>
	</aop:config>
</beans>

测试

package spring_day02;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.itcast.aop.Book;

public class AopTest {
	@Test
	public void Test() {
		ApplicationContext con = new ClassPathXmlApplicationContext("bean3.xml");
		Book book = (Book) con.getBean("book");
		book.add();
	}
}

结果

log4j:WARN No appenders could be found for logger (org.springframework.core.env.StandardEnvironment).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
前置增强........
方法之前............
add.....
方法之后............
后置增强.........

Log4j介绍

1.通过log4j可以看到程序过程中更详细的信息
（1）经常使用log4j查看日志
2.使用
（1）导入log4j的jar包
（2）复制log4j的配置文件，赋值到src下面（在src下面创建log4j.properties配置文件）
在这里插入图片描述
3.设置日志级别

（1）info：看到基本信息
（2）debug：看到更详细的信息
Spring整合web项目演示
1.演示问题
（1）action调用service , service调用dao
（2）每次访问action的时候，都会加载spring配置文件，性能大大降低
在这里插入图片描述
2.解决方法
（1）在服务器启动的时候，创建对象加载配置文件
（2）底层使用监听器、Servletcontext对象
3.在spring里面不需要我们自己写代码实现，spring自己封装了
（1）封装了一个监听器，只需要配置监听器就可以了（web.xml进行配置）
（2）配置监听器之前需要导入spring整合web项目的jar包
在这里插入图片描述
（3）在web.xml文件中可用快捷键Ctrl+Shift+t

（4）指定加载spring配置文件的位置
因为spring官方默认的文件名称及路径如下：

（5）在web.xml文件指定sprin配置文件路径

<!--指定spring配置文件位置  -->
	<context-param>
	 <param-name>contextConfigLocation</param-name>
	 <param-value>classpath:bean1.xml</param-value>
	</context-param>

启动服务器，通过日志文件可以查看到，服务器启动的时候就启动对象加载配置文件进行对象创建：
在这里插入图片描述
实力项目结构图：

所需jar包：

实例代码：
UserAction.java

package cn.itcast.action;

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

import com.opensymphony.xwork2.ActionSupport;

import cn.itcast.service.UserService;

public class UserAction extends ActionSupport {

	@Override
	public String execute() throws Exception {
		System.out.println("action...........");
		ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
		UserService userService = (UserService) context.getBean("userService");
		userService.add(); // 调用UserService的方法
		return NONE;
	}
}

UserDao.java

package cn.itcast.dao;

public class UserDao {

	public void add() {
		System.out.println("dao.......");
	}
}

UserService.java

package cn.itcast.service;

import cn.itcast.dao.UserDao;

public class UserService {

	private UserDao userDao;

	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

	public void add() {
		System.out.println("service......");
		userDao.add();  //调用UserDao中的add()方法
	}
}

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

	<bean id="userService" class="cn.itcast.service.UserService">
		<property name="userDao" ref="userDao"></property>
	</bean>
	<bean id="userDao" class="cn.itcast.dao.UserDao"></bean>

</beans>

log4j.properties

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=info, stdout

struts.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC 
"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" 
"http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
	<package name="demo1" extends="struts-default" namespace="/">
		<action name="userAction" class="cn.itcast.action.UserAction"></action>
	</package>
</struts>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://xmlns.jcp.org/xml/ns/javaee"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
	id="WebApp_ID" version="3.1">
	<display-name>spring_day02_webdemo</display-name>
	<!--指定spring配置文件位置  -->
	<context-param>
	 <param-name>contextConfigLocation</param-name>
	 <param-value>classpath:bean1.xml</param-value>
	</context-param>
	
	<!--配置struts 2框架的核心Filter -->
	<filter>
		<!--过滤器名 -->
		<filter-name>struts2</filter-name>
		<!-- 配置Struts 2.3.16的核心Filter的实现类 -->
		<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
	</filter>
	<!-- 让Struts 2的核心Filter拦截所有请求 -->
	<filter-mapping>
		<!--过滤器名 -->
		<filter-name>struts2</filter-name>
		<!-- 匹配所有请求 -->
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	
	<!--配置监听器  -->
	<listener>
	  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	
	<welcome-file-list>
		<welcome-file>index.html</welcome-file>
		<welcome-file>index.htm</welcome-file>
		<welcome-file>index.jsp</welcome-file>
		<welcome-file>default.html</welcome-file>
		<welcome-file>default.htm</welcome-file>
		<welcome-file>default.jsp</welcome-file>
	</welcome-file-list>
</web-app>

高风言

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring框架知识点（二）

目录：1.spring的bean管理（注解）（1）使用注解创建对象（2）使用注解注入属性（3）Xml和注解方式混合使用2.AOP（1）Aop概述（2）Aop底层原理（3）Aop操作相关术语3.spring的aop操作（基于aspectj的xml方式）4.Log4j介绍5.Spring整合web项目演示1.spring的bean管理（注解）注解介绍1.代码里面特殊标记，使...
复制链接

扫一扫

专栏目录