spring初探2

最新推荐文章于 2021-11-20 22:47:15 发布
最新推荐文章于 2021-11-20 22:47:15 发布
阅读量136 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hui1097/article/details/109682901
版权

书接上文！！

11，异常通知（schem-base方式下）

  1. 新建一个类实现ThrowsAdvice接口
    1.1必须自己写方法，且方法名必须叫afterThrowing
    1.2有两种参数方式
    1.2.1必须是1个或4个
    1.3异常与切点报的切点的异常一致
package com.mywolf.advice;
import java.lang.reflect.Method;
import java.rmi.RemoteException;

import javax.servlet.ServletException;

import org.springframework.aop.ThrowsAdvice;
public class MyThrow implements ThrowsAdvice{
//    public void afterThrowing(Exception ex) throws Throwable {
//      System.out.println("执行异常通知通过schema-base方式");
//    }

    public void afterThrowing(Method m, Object[] args, Object target, Exception ex) {
        // Do something with all arguments
    	System.out.println("执行异常通知通过schema-base方式");
    }
}

2.	在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: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/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd">
	<bean id="mythrow" class="com.mywolf.advice.MyThrow"></bean>
	<aop:config>
		<aop:pointcut
			expression="execution(* com.mywolf.test.Demo.demo01())"id="mypoint" />
		<aop:advisor advice-ref="mythrow" pointcut-ref="mypoint" />
	</aop:config>
	<bean id="demo" class="com.mywolf.test.Demo"></bean>
</beans>

12.环绕通知

1.环绕通知的概念：把前置通知和后置通知都写在同一个通知里就构成了环绕通知。
实现步骤：
编写一个类，实现MethodInterceptor接口

public class MyArround  implements MethodInterceptor{

	@Override
	public Object invoke(MethodInvocation arg0) throws Throwable {
		System.out.println("环绕-前置");
		Object proceed = arg0.proceed();//方行，调用切点方法
		System.out.println("环绕-后置");
		return proceed;
	}
  
}

配置applicationContext.xml
	<bean id="demo" class="com.mywolf.test.Demo"></bean>
	<bean id="myarround" class="com.mywolf.advice.MyArround"></bean>
	<aop:config>
	  <aop:pointcut
			expression="execution(* com.mywolf.test.Demo.demo01())" id="mypoint" />
		<aop:advisor advice-ref="myarround" pointcut-ref="mypoint" />
	</aop:config>
</beans>

13.关于aspectj方式：
新建一个类，类中方法名任意

package com.mywolf.advice;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyAdvice {
	public void mybefore(String name1, int age1) {
		// 前置通知
		System.out.println("前置通知" + name1);
	}

	public void mybefore1(String name1) {
		// 前置通知
		System.out.println("前置通知" + name1);
	}

	public void myafter() {
		// 后置通知
		System.out.println("后置通知1");
	}

	public void myafterning() {
		// 后置通知
		System.out.println("后置通知2");
	}

	public void mythrow() {
		// 后置通知
		System.out.println("异常");
	}

	public Object myarround(ProceedingJoinPoint p) throws Throwable {
		// 环绕通知
		System.out.println("环绕-前置");
		Object proceed = p.proceed();
		System.out.println("环绕-后置");
		return proceed;
	}
}

  配置applicationContext.xml配置文件
	<bean id="demo" class="com.mywolf.test.Demo"></bean>
	<bean id="myadvice" class="com.mywolf.advice.MyAdvice"></bean>
	<!-- 使用aspect方式完成各种通知 -->
	<!-- <aop:config> <aop:pointcut expression="execution(* com.mywolf.test.Demo.demo01())" 
		id="mypoint" /> <aop:advisor advice-ref="myarround" pointcut-ref="mypoint" 
		/> </aop:config> -->
	<aop:config>
		<aop:aspect ref="myadvice">
			<aop:pointcut
			expression="execution(* com.mywolf.test.Demo.demo01(String,int)) and args(name1,age1)" id="mypoint" />
		     <aop:pointcut
				expression="execution(* com.mywolf.test.Demo.demo01(String)) and args(name1)" id="mypoint1" />
		     <aop:before method="mybefore" pointcut-ref="mypoint" arg-names="name1,age1"/>
		      <aop:before method="mybefore1" pointcut-ref="mypoint1" arg-names="name1"/>
		<!--      <aop:after method="myafter" pointcut-ref="mypoint"/>
		     <aop:around method="myarround" pointcut-ref="mypoint"/> -->
		</aop:aspect>
	</aop:config>

解释：
1.<aop:after：后置通知，不管是否出现异常都会执行的通知
2.<aop:after-returning method=""/>：也是后置通知，只有切点没有异常正常执行的时候才会执行
3. <aop:after-throwing method=""/>和<aop:after：和<aop:after-returning method=""/>的执行顺序与他们在配置文件中的顺序有关。
4.特别注意红字部分的写法以及他们参数的写法都要保持对应（位置和名字都必须对应）

13.使用注解（基于 Aspect）
1.spring不会自动去寻找注解，必须告诉spring哪些包下的类中可能有注解
1.1引入xmlns:context=http://www.springframework.org/schema/context
并添加 http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

<!—组键扫描 -->    
   <context:component-scan base-package="com.mywolf.advice"></context:component-scan>
   

若扫描多个包则用逗号隔开
<context:component-scan base-package="com.mywolf.advice，com.mywolf.test">
</context:component-scan>
   
2.@Component
  2.1相当于<bean />
  2.1如果没有参数把类名首字母变小写，相当于<bean id=””>
  2.3@Component(“自定义名称”)
3.实现步骤
   3.1在spring配置文件中，设置注解在哪个包中
     <!--组键扫描 -->     
   <context:component-scan base-package="com.mywolf.advice ,com.mywolf.test">
   </context:component-scan>
   3.2对于有切点的类
package com.mywolf.test;

import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
public class Demo {
	//定义切点
 @Pointcut("execution(* com.mywolf.test.Demo.demo01())")
 public void demo01() {
	 
//	 int i= 5/0;
	 System.out.println("demo01");
 }

}


对于含有通知的类
package com.mywolf.advice;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class MyAdvice {
	@Before("com.mywolf.test.Demo.demo01()")
	public void mybefore() {
		System.out.println("前置");
	}

}
  最后使用cglib代理（在配置文件中）
<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>

16.动态代理

1.为了解决静态代理频繁编写代理功能的缺点
2.动态代理的分类
2.1jdk动态代理
2.2cglib动态代理
3.JDK动态代理
1.和cglib动态代理相比
1.1优点：jdk自带，不需要额外导入jar
1.2缺点
1.2.1真实对象必须实现接口
1.2.2利用反射机制，效率不高
4.cglib动态代理
1.cglib优点：
1.1基于字节码文件（编译后的.class文件），生成真实对象的子类
1.2运行效率高于JDK动态代理
1.3不需要实现接口
5.使用spring-aop时，只要出现Proxy和真实对象转换异常
5.1设置为true使用cglib
5.2设置false使用jdk（默认值）
<aop:aspectj-autoproxy proxy-target-class=“true”></aop:aspectj-autoproxy>

17.自动注入

1.在spring配置文件中对象名和ref=“id” id名相同使用自动注入，可以不配置
2.两种配置办法
2.1在中通过autowire=“”配置，只对这个生效
在这里插入图片描述
3. autowire可取值
3.1default：默认值，根据全局default-autowire=‘’‘’值，默认全局和局部都没有配置的情况写就是no，不使用自动注入：
3.2no：不自动注入
3.3byName:通过名称自动注入，在spring容器中找类的id
3.4byType:根据类型注入
3.4.1spring容器中不可以出现两个相同类型的
3.5constructor:根据构造方法注入
3.5.1提供对应参数的构造方法（构造方法参数中包含注入那个注入对象）
3.5.2底层使用byName构造方法参数名和其他的id相同

18.spring中加载properties属性文件：

1.在src下新建xxx.properties属性文件
2.在spring配置文件中先引入xmls:context 对象命名空间和属性命名空间
2.1如果需要加载多个配置文件就用逗号分隔（其中classpath：表示src文件下）
<context:property-placeholder location=“classpath:db.properties”/>
3.添加了属性文件加载，并且在中开启了自动注入
3.1注意扫描的配置文件的写法特别注意红字部分的写法，不能再用sqlSessionFactory
和ref 而要用name=“sqlSessionFactoryBeanName” value=“factory” 用ref不行的原因在于对象在创建的时候还没有加载属性文件对对象的属性赋值，导致出错

<!-- 扫描器相当于mybatis.xml中mappers下的package标签 -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<!-- 要扫描哪个包 -->
		<property name="basePackage" value="com.mywolf.mapper"></property>
		<!-- 和factory产生关系 -->
		<property name="sqlSessionFactoryBeanName" value="factory"></property>
	</bean>

4.在被spring管理的类中通过@Value（“${key}”）取出properties（属性文件中的值）
   4.1使用注解要在配置文件中添加注解扫描
<context:component-scan base-package="包名"></context:component-scan>
   4.2在类中添加
      4.2.1key和变量名可以不同
      4.2.2变量类型任意，只要保证key对应的value能转换成这个类型就行（也就是属性文件中的属性值应该能够赋值给要赋值的变量）
	@Value("${key}")
	private String test;

19scope属性

1.的属性
2.作用：控制对象的有效范围（单例（全程只有一个对象）、多例（全程可以有多个对象））
3.标签对应的对象默认是单例的
3.1也就是在默认情况下使用标签由spring创建对象时一个标签对应一个对象，无论从spring容器中取多少次（同一个标签创建对应的对象）都是同一个对象。
4.scope可取值
4.1singleton :默认值，单例
4.2 prototype 多例，即每次取同一个标签的对象都会重新创建对象
4.3request 每次request请求都会重新创建一个对象（使用springMVC框架中用到）
4.4session 每个会话对象内，对象是单例的
4.5application 在application对象内是单例
4.6global session spring 推出 的一个对象，依赖于spring-webmvc-portlet，类似于session

5.单例模式（保证在程序运行过程中只有一个对象）
1.作用：在应用程序中保证最多只能有一个实例
2.优点：
2.1提升运行效率
2.2 实现数据共享 案例：application对象
3懒汉式
3.1对象只有被调用时才去创建
3.2实例代码

package com.mywolf.single;
/**
 * 
 * @author huihui
 *懒汉式单例设计模式
 */
public class SingleTon {
   private  static SingleTon singleton;
   /**
    * 不让其通过new来创建重复的对象
    * 
    */
   private SingleTon(){
	   
   }
   
   public static SingleTon getSingleTon() {
	   //添加逻辑，如果已经实例化过就直接返回
	   if(singleton==null) {
		  /**
		   * 多线程的情况下，可能出现多个线程同时访问这个if因此加上锁
		   */
		   synchronized(SingleTon.class) {
			   /**
			    * 双重验证
			    */
			   if(singleton==null) {
				   singleton=new SingleTon();
				   return singleton; 
			   }  
		   }
	   }
	return singleton;  
   }
}

Test
package com.mywolf.single;

public class Test {
	public static void main(String[] args) {
		 SingleTon singleton1=SingleTon.getSingleTon();
		 SingleTon singleton2=SingleTon.getSingleTon();
		 System.out.println(singleton1==singleton2);
	}

}
3.3缺点：由于添加了锁导致效率低
       4.饿汉式
         4.1解决了懒汉式中多线程访问可能出现同一个对象效率低的问题
         
package com.mywolf.single;
/**
 * 
 * @author huihui
 *饿汉式单例设计模式(当这个类被加载的时候就立马创建对象)
 */
public class SingleTon {
   private  static SingleTon singleton=new SingleTon();
   /**
    * 不让其通过new来创建重复的对象
    * 
    */
   private SingleTon(){
	 
   }
   public SingleTon getSingleTon() {
	   return singleton;
   }
}

20.声明式事务

1.编程式事务
1.1由程序员编程事务控制代码
1.2OpenSessionInView 编程式事务
2.声明式事务
2.1事务控制代码已经由spring写好，程序员只需要声明出哪些地方需要进行事务控制和如何进行事务控制
3.声明式事务都是针对于ServiceImpl类下的方法（service里面写的就是业务（一个业务对应一个事务））
4.事务管理器是基于通知的（advice）

<!-- 声明式事务 -->
 <!-- 数据源 -->  
    <context:property-placeholder location="classpath:db.properties"/>
	<bean id="dataSouce" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="${jdbc.driverClassName}"></property>
		<property name="url" value="${jdbc.url} "></property>
		<property name="username" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>
	</bean>
          <!-- 第二步配置声明式事务 -->             
         <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
          <property name="dataSource" ref="dataSouce"></property><!-- 事务是要提交给数据库的因此要跟数据库连起来 -->
         </bean><!-- 这是一个事务管理器 -->
         <!-- 配置声明式事务 -->
         <tx:advice  id="txadvice" transaction-manager="txManager">
           <tx:attributes>
           <!-- 哪些方法需要有事务控制 -->
           <!-- 也支持通配 -->
         <!--    <tx:method name="insert"/> -->
             <tx:method name="ins*"/><!-- 就是表示以ins开头的所有方法 -->
             <tx:method name="upd*"/><!-- 就是表示以upd开头的所有方法 -->
             <tx:method name="del*"/><!-- 就是表示以del开头的所有方法 -->
           </tx:attributes>
         </tx:advice>
          <!-- 第一步还是配置切点 -->
          <aop:config>
           <aop:pointcut expression="execution(* com.mywolf.service.impl.*.*(..))" id="mypoint"/>
           <aop:advisor advice-ref="txadvice" pointcut-ref="mypoint"/>
          </aop:config>

5声明式事务属性解释（<tx:method name=“ins*”/>后的属性）

  1. name=“”属性：哪些方法需要有事务控制
    1.1支持*通配符
    2.readonly=“booblean”是否是只读事务
    2.1如果为true，告诉数据库此事务为只读事务，数据库优化，会对性能有一定提升，所以只要是查询的方法，建议使用此数据。
    2.2如果为false（默认值），事务需要提交的事务，建议新增，删除，修改
    3.propagation 控制事务传播行为
    3.1当一个具有事务控制的方法被另一个有事务控制的方法调用后，需要如何管理事务（新建事务?在事务中执行?把事务挂起?报异常？）
    3.2默认值：REQUIRED如果当前有事务，就在事务中执行，如果当前没有事务，新建一个事务。
    3.3 SUPPORTS： 如果当前有事务，就在事务中执行，如果当前没有事务，就在非事务状态下执行
    3.4 MANDATORY：必须在事务内部执行，如果当前有事务，就在事务中执行，如果没有事务，报错
    3.5 REQUIRES_NEW：必须在事务中执行，如果当前没有事务，新建事务，如果当前有事务，把当前事务挂起。
    3.6 NOT_SUPPORTED：必须在非事务下执行，如果当前没有事务，正常执行，如果当前有事务，把当前事务挂起
    3.7 NEVER：必须在非事务状态下执行，如果当前没有事务，正常执行，如果当前有事务，报错
    3.8. NESTED:必须在事务状态下执行，如果当前没有事务，新建事务，如果当前有事务，创建一个嵌套事务。

  2. isolation=“”事务隔离级别
    4.1在多线程或并发访问下如何保证访问到的数据具有完整性的（数据是对的）
    4.2脏读
    4.2.1一个事务（事务A）读取到另一个事务(事务B)中未提交的数据，另一个事务（事务B）中的数据可能发生了改变，此时A事务读取的事务可能和数据库中的数据不一致，此时认为数据是脏数据，读取数据过程叫脏读。
    4.3不可重复读
    4.3.1主要针对的是某行数据（或行中某列）
    4.3.2主要针对的操作是修改操作
    4.3.3两次读取在同一个事务内
    4.3.4当事务A第一次读取事务之后，事务B对事务A读取的数据进行修改，事务A中再次读取的数据和之前读取的数据不一致，过程不可重复。
    4.4幻读
    4.4.1主要针对的操作是新增或删除
    4.4.2两次事务的结果
    4.4.3事务A按照特定条件查询出结果，事务B新增了一条符合条件的数据。事务A中查询的数据和数据库中的数据不一致，事务A好像出现了幻觉，这种情况称为幻读。

  3. isolation可取值：

    1. DEFAULT：默认值，由底层数据库自行判断应该使用什么隔离级别
    2. READ_UNCOMMITTED：可以读取未提交数据，可能出现脏读、不可重复读、幻读
      （但是他的效率最高）
      3.READ_COMMITTED：只能读取其他事务已经提交的数据，可以防止脏读，可能出现不可重复读和幻读。

  4. REPEATABLE_READ：读取的数据被添加锁，防止其他事务修改此数据，可以防止不可重复读和脏读，可能出现幻读

  5. SERIALIZABLE：排队操作，对整个表添加锁，一个事务在操作数据时，另一个事务等待这个事务操作完成后才能操作这个表。（最安全，效率最低）
    6.事务回滚rollback-for=“异常类型的全限定路径（如java.lang.Exception）”
    6.1当出现什么异常时需要进行回滚
    6.2建议：给定该属性值
    6.2.1手动抛异常一定要给该属性值（手动抛异常：throw new Exception）

  6. no-rollback-for=""当出现什么异常时不回滚事务。

21.spring中常用注解
1 @Component 创建对象，相当于配置
2 @Service 与@Component 功能相同
写在serviceImpl类上
3 @Repository 与@Component 功能相同
写在数据访问层类上
4 @Controller 与@Component 功能相同
写在控制器类上
5 @Resource 和 @Autowired 的区别
@Resource 不需要写对象的get /set @Autowired不需要写对象的get /set
Java中的注解 Spring中的注解

默认按照byName注入，如果没有名称对象
按照byType注入 默认按照byType注入

7.@Value()获取 properties（属性文件）中的内容
8.@pointcut()定义切点
9.Aspect()定义切面类
10.@Before()前置通知
11.@After（）后置通知
12.@AfterReturning 后置通知，必须切点正确执行
13@AfterThrowing 异常通知
14@Arround环绕通知

封狼居士
关注
专栏目录
spring 初探
03-18
标题中的“spring 初探”表明我们即将探讨的是Spring框架的基础知识。Spring是Java企业级应用开发中最常用的一个开源框架，由Rod Johnson发起，旨在简化应用程序的开发，提高组件之间的解耦。 首先，Spring框架的...
Mybatis入门第三课 SqlSessionFactoryBuilder,SqlSessionFactory,SqlSession
weixin_40839342的博客
05-31 612
// 核心配置文件 String resource = "SqlMapConfig.xml"; // 通过流将核心配置文件加载进来 InputStream inputStream = Resources.getResourceAsStream(resource); // 通过配置文件创建会话工厂 SqlSessionFactory factory = new SqlSessionFactoryBu...
IDEA解决quartz配置中ref变量报红问题
YQS_Love的博客
03-16 5174
一、问题描述   在使用Quartz时，都需要在***_quartz.xm中配置触发条件以及具体的逻辑。在保证quartz.xml配置语法正确的情况下，task:scheduled的ref引用的变量会报红，并且还能看到Cannot resolve bean ‘name’这样的提示（如下图）。产生这样的情况只有一种可能，那就是Spring Application Context配置不正确，导致ID...
MyBatis SqlSessionFactory的几种常见创建方式
热门推荐
Lover
10-18 3万+
MyBatis框架主要是围绕着SqlSessionFactory这个类进行的，这个的创建过程如下： 定义一个Configuration对象，其中包含数据源、事务、mapper文件资源以及影响数据库行为属性设置settings通过配置对象，则可以创建一个SqlSessionFactoryBuilder对象通过 SqlSessionFactoryBuilder 获得SqlSessionFacto
org.apache.ibatis.session.SqlSessionFactory包导不进，报红
Jemmy的博客
03-17 9674
第一步： 第二步，点击右侧的加号，添加入包： 没报错了。
SpringCache缓存初探共5页.pdf.zip
10-30
在这个“SpringCache缓存初探共5页.pdf.zip”压缩包中，很可能是对SpringCache的基础知识进行了简要介绍。虽然文件名暗示内容可能只有5页，但我们可以深入探讨SpringCache的一些核心概念和技术细节。 首先，Spring...
Spring security初探
04-15
NULL 博文链接：https://yzxqml.iteye.com/blog/1756106
1.2 引入SpringSecurity 2. 认证 2.1 登陆校验流程 2.2 原理初探 2.2.1 SpringSecur
最新发布
09-13
2. 认证 2.1 登陆校验流程 2.2 原理初探 2.2.1 SpringSecurity完整流程 2.2.2 认证流程详解 2.3 解决问题 2.3.1 思路分析 2.3.2 准备工作 2.3.3 实现 2.3.3.1 数据库校验用户 准备工作 核心代码实现 2.3.3.2 密码...
ssm框架下配置声明事务正确就是不起作用
bellus
09-07 7959
关键点：spring MVC 和 spring 是两个管理，自动扫描service 的bean必须在spring的配置文件中。 默认前提是：声明事务和配置没有问题，就是不回滚。 环境代码介绍： springMVC配置文件： spring 的配置文件：（没有扫描任何包文件，有spring全部扫描并加载） w
org.mybatis.spring.SqlSessionFactoryBean 报红
b348858003的博客
11-20 5172
这种情况说明pom.xml下缺少依赖 <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.1</version> </dependency> 将以上的复制到pom.xml即可 如果有帮到大家，麻烦大家在下面.
数组array(基础，加args讲解)
wenshao007的博客
02-22 741
https://blog.csdn.net/wenshao007/article/details/103592633 基础的定义方法在上面链接 数组： 1.是一种引用类型，不是基本数据类型 2.数组是一种简单的数据结构，线性的结构。 3.数组是一个容器，可以用来存储其他元素 数组是可以存储任意的数据类型的元素 4.数组分为：一维数组，二维数组，三维数组，多维数组 Object o1 = new ...
基于管道过滤器风格的-KWIC
hui1097的博客
11-20 5398
1、题前分析 kwic是什么到低要解决什么问题？ 看这段英文的变化，输入的值的是绿色圈出的部分，第一次处理后的结果是橙色圈出的部分，第三次处理的结果是红色圈出的部分，第一次处理，先是对句话进行了切分，是按照单词之间的空格进行切分，将一整句话切分成多个单词，然后对这些单词的进行移位，每次都将第一个单词放在末尾从而组成新的句子，这样经过第一次处理之后，HELLO WORLD 这句话就变成了两句话HELLO WORLD 和WORLD HELLO。接下来进行第二步处理，对这几句话按照首字母进行排序，从而得到最终
面向对象风格的-KWIC
hui1097的博客
11-22 1963
1、什么是面向对象风格？什么是面向对象风格？什么是面向对象风格？ 看图： 这个图来自博客：https://blog.csdn.net/qq_41626229/article/details/85930248?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522160603771419725225056063%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%25
JAVAWeb实验
hui1097的博客
07-04 1665
一、实验目的 实现留言的删除、更新，并且要求有session的会话。 二、实验内容 1.对用户是否登陆作出验证，未登陆自动跳转回登陆页面 2.获得要修改的记录（通过list_notes.jsp中传递过来的id） 3.将记录按id查询出来填写在表单中，并继续向updatemessage.jsp进行传递（通过隐藏表单，目的是不暴露给用户） 4.对数据库进行删除操作（通过message.jsp中传递过来...
基于kwic的bs系统
hui1097的博客
12-23 710
1、先看项目结构： jar包：划红线的是自己做的jar包网上没有，其余的jar包在相应的网站可以找到 2、再看项目描述： 前端： 页面效果展示： 前端通过jQuery的按键点击keyon事件,在事件发送ajax请求，将<textarea> 内的数据以post请求的方式发给服务端demo1,demo1使用相关的对象，完成kwic算法（具体看代码注释，太多不想敲），并且将处理好的数据返回给客户端，在右边的<textarea>中有一个保存按钮，为按钮添加了点击事件，点击按钮后，会发
编写简单的Struts2程序
hui1097的博客
04-18 540
实验一 编写简单的Struts2程序 一、实验目的 能正确配置Struts 2开发环境，了解和熟悉Struts 2的开发流程、了解和熟悉Struts2标签的使用方法。 二、实验要求 1.正确创建Action类; 2.配置struts.xml文件; 3.掌握在视图中访问Action的方法. 4. 掌握在视图中多方法调用同一个Action的方法 5.掌握常用标签textfield、radio、paa...
java反射机制
hui1097的博客
05-28 220
/** * * @author huihui *1.Java的动态性 *• 反射机制 • 动态编译 • 动态执行javascript代码 • 动态字节码操作 * *• 反射机制 – 指的是可以于运行时加载、探知、使用编译期间完全未知的类。 *– 程序在运行状态中，可以动态加载一个只有名称的类，对于任意一个 已加载的类， *都能够知道这个类的所有属性和方法；对于任意一个对 象，都能够调用它的任意一个方法和属性； Class c = Class. f o r N a m...
spring初探
hui1097的博客
11-13 196
spring初探 1． 主要发明者：Rod Johnson 2． 轮子理论推崇者： 2.1不要重复发明轮子 2.2直接使用写好的代码 3.## spring框架的宗旨：不重复发明技术，让原有技术使用起来更加方便 （spring不是哪一层的框架，而是每一层都有） 4## .spring几大核心功能 4.1IoC/DI 控制反转/依赖注入 4.2AOP 面向切面编程 4.3声明式事务 5## ．Spring框架的运行时环境 5.1test：spring提功的测试功能 5.2CoreContainer
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值