Spring 框架 四天学习笔记_day03

最新推荐文章于 2025-09-09 09:10:31 发布
原创 最新推荐文章于 2025-09-09 09:10:31 发布 · 315 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #javaee #javaweb #aop #ID

本文详细介绍了Spring AOP的应用、Spring整合JDBC的方法及示例代码，并讲解了如何利用Spring进行事务管理。

1.复习

        1. spring . aop开发  

                    aop思想， 纵向重复， 横向抽取

                             |-filter 中

                             |-动态代理    

                             |-interceptor 中  struts2框架中的拦截器

                     spring AOP : 封装了动态代理技术， 来体现aop

                      springaop实现： 可以对所有的对象代理

                             |-动态代理， 代理实现接口 

                             |-cglib代理，对目标对象继承代理

                     springaop名词： 

                                            join point ： 连接点， 所有可以植入通知的方法

                                            point cut : 切入点，需要已经织入的通知的方法

                                            advice ： 需要增强的代码

                                            weaving： 动词， 将通过应用的切点的过程

                                            target : 目标对象 

                                            proxy ： 代理对象 

                                            aspect ： 切面，切入点，+ 通知

           2.spring 中的springaop 的应用

                1.导包
4+2
2 aop+aspect
2 aop联盟+weaving
2.准备目标对象


3.准备通知类
前置通知
后置通知 方法正常结束
环绕通知
异常拦截通知
后置通知 无论如何都执行

4.配置文件中配置,导入aop约束
1>目标对象
2>通知对象
3><aop:config>
<aop:ponint-cut id="切点名称" expression="execution(切点表达式)" />
<aop:aspect ref="通知对象名称" >
<aop:before method="" ponintcut-ref=""  />
<aop:after-returning method="" ponintcut-ref=""  />
<aop:around method="" ponintcut-ref=""  />
<aop:after-throwing method="" ponintcut-ref=""  />
<aop:after method="" ponintcut-ref=""  />
</aop:aspect>

扩展:使用注解完成aop
1.导包
4+2
2 aop+aspect
2 aop联盟+weaving
2.准备目标对象


3.准备通知类
4.配置文件中配置,导入aop约束
1>目标对象
2>通知对象
3><aop:aspect-autoproxy> 开启注解aop

5.注解
@Aspect 指定当前类是通知类

@Before 前置通知方法
@after-returning 后置通知方法
@around 环绕通知方法
@after-throwing 异常拦截通知方法
@after 后通知方法

@PointCut 抽取切点表达式

2.spring整合jdbc  (spring 中封装了jdbc对象， 通过这个对象可以操作数据库，这个对象叫做，JDBCTemplate, 和dbutils 中的queryrunner 几乎一模一样)


       2.1 整合jdbc 模板

    1. 导包


        2.使用核心类，操作数据库

    

	@Test
	public void test() throws Exception {
		// 0. 准备连接池
		ComboPooledDataSource dataSource = new ComboPooledDataSource(); 
		dataSource.setJdbcUrl("jdbc:mysql:///hibernate");
		dataSource.setDriverClass("com.mysql.jdbc.Driver");
		dataSource.setUser("root");
		dataSource.setPassword("123456");
		
		
		// 1.创建jdbc 模板对象 
		JdbcTemplate jt = new JdbcTemplate(dataSource); 
		
		// 书写sql 
		String sql = "insert into s_user values(3,'rose','4545')" ; 
		jt.update(sql); 
	}
2.2  演示

        1.定义dao 接口

package com.zzq.dao;

import java.util.List;

import com.zzq.domain.User;

/**
 *  dao 定义对user 的操作
 * @author ZZQ.Hacker
 *
 */
public interface UserDao {

	 void add (User user); 
	 void delete(Integer id ) ; 
	 void update(User user);
	  List<User> findAll(); 
	  User getById(Integer id ) ;
	 Integer getTotalCount();
	 
}

2.定义dao 实现类

package com.zzq.dao.impl;


import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import com.zzq.dao.UserDao;
import com.zzq.domain.User;

@SuppressWarnings("all")
public class UserDaoimpl  implements UserDao {
	private static JdbcTemplate jt ; 
	static{
		try{
		// 0. 准备连接池
				ComboPooledDataSource dataSource = new ComboPooledDataSource(); 
				dataSource.setJdbcUrl("jdbc:mysql:///hibernate");
				dataSource.setDriverClass("com.mysql.jdbc.Driver");
				dataSource.setUser("root");
				dataSource.setPassword("123456");
				
				
				// 1.创建jdbc 模板对象 
			 jt = new JdbcTemplate(dataSource); 
		}catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
	
	public void add(User user) {
		String sql = "insert into s_user values(?,?,?); " ; 
		jt.update(sql, user.getId(),user.getName(),user.getPassword()); 
	}


	public void delete(Integer id) {
		String sql = "delete from s_user where id = ?  " ;
		jt.update(sql,id); 
	}

	public void update(User user) {
		String sql = "update s_user set name=? password=? where id=?  " ; 
		jt.update(sql,user.getName(),user.getPassword(),user.getId()); 
	}


	public List<User> findAll() {
		String sql =  "select * from s_user" ; 
		List<User>  users= jt.query(sql, new RowMapper<User>(){

			public User mapRow(ResultSet rs, int arg1) throws SQLException {
				User user = new User()  ; 
				user.setId(rs.getInt("id"));
				user.setName(rs.getString("username"));
				user.setPassword(rs.getString("password"));
				return user;
			}
			
		}); 
		return  users;
	}
	
	
	

	public User getById(Integer id) {
		String sql = "select * from s_user where id = ? ";
		User user = jt.queryForObject(sql,new RowMapper<User>(){

			public User mapRow(ResultSet rs, int arg1) throws SQLException {
				// 把resultset 中的内容取出，然后进行 封装，  int 是索引 
				User  u = new User() ;
				u.setId(rs.getInt("id"));
				u.setName(rs.getString("name"));
				u.setPassword(rs.getString("password"));
				return u  ;
			}
			
		}, id );  
		
		return   null  ; 
	}


	public Integer getTotalCount() {
			String sql =  "select count(*) from s_user"; 
			return jt.queryForObject(sql, Integer.class); 
			
	}
 
	
}

4.测试

package com.zzq.jdbctempate;

import java.util.List;



import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;


import com.mchange.v2.c3p0.ComboPooledDataSource;
import com.zzq.dao.UserDao;
import com.zzq.dao.impl.UserDaoimpl;
import com.zzq.domain.User;

/**
 * 演示jdbc 模板
 * @author ZZQ.Hacker
 *
 */
public class Demo {

	private UserDao u  =new UserDaoimpl(); 
	
	
	@Test
	public void test() throws Exception {
		// 0. 准备连接池
		ComboPooledDataSource dataSource = new ComboPooledDataSource(); 
		dataSource.setJdbcUrl("jdbc:mysql:///hibernate");
		dataSource.setDriverClass("com.mysql.jdbc.Driver");
		dataSource.setUser("root");
		dataSource.setPassword("123456");
		
		
		// 1.创建jdbc 模板对象 
		JdbcTemplate jt = new JdbcTemplate(dataSource); 
		
		// 书写sql 
		String sql = "select *  from s_user" ;
		List query = jt.query(sql,new BeanPropertyRowMapper(User.class)); 
		System.out.println(query);
	}
	
	
	
	@Test
	public  void test_findAll(){
		List<User> list = u.findAll(); 
		System.out.println(list);
		
	}
	
}

3.jdbc连接池，dao 配置到spring容器中

        bug : 注意， 这里要理解， spring其实就是一个容器， 通过配置文件可以放入中， 配置文件可以是set 放入 ， 和构造方法放入， 然后我们通过注解 @reSource  进行取出， 所以放进去的需要的时候就可以进行取出， 我今天就在这里犯了个错误 ，存入了jdbcTemplate 但是没有取出 ，然后我就直接想进行获取dao 然后进行查询 代码如下 

    1. daoimpl 层代码

package com.zzq.dao.impl;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import javax.annotation.Resource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import com.zzq.dao.UserDao;
import com.zzq.domain.User;

public class UserDaoimpl extends JdbcDaoSupport implements UserDao {
	@Resource(name="jdbcTemplate")
	private JdbcTemplate jt; 

	public Integer getTotalCount() {
		String sql = "select count(*) from s_user  ";
		Integer count = super.getJdbcTemplate().queryForObject(sql, Integer.class);
		return count;
	}

	public List<User> findAll() {
		String sql = "select * from s_user  ";
		List<User> list = jt.query(sql, new RowMapper<User>(){
			public User mapRow(ResultSet rs, int arg1) throws SQLException {
				User u = new User();
				u.setId(rs.getInt("id"));
				u.setName(rs.getString("username"));
				u.setPassword(rs.getString("password"));
				return u;
			}});
		return list;
	}


}  // 这里注意， 一定要从spring 中取出 ，对象 ，然后才能进行操作

配置文件如下： 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" 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-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">

	<bean name="user" class="com.zzq.domain.User"></bean>
	
	

	<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
				<property name="jdbcUrl" value="jdbc:mysql:///hibernate"></property>
				<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
				<property name="user" value="root" ></property>
				<property name="password" value="123456"></property>
	</bean>
	
	
	<bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
 	<bean name="userDao" class="com.zzq.dao.impl.UserDaoimpl">
		<property name="dataSource" ref="dataSource"></property>
	</bean> 
	

</beans>

测试如下 : 

package com.zzq.jdbctempate;



import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import javax.annotation.Resource;
import javax.sql.DataSource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.zzq.dao.UserDao;
import com.zzq.dao.impl.UserDaoimpl;
import com.zzq.domain.User;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo2 {

	@Resource(name="userDao")
	private UserDao us ;  
	
	@Test
	public void test(){
		System.out.println(us.findAll());
	}
	
	
	@Test
	public void test2(){
		System.out.println(us.getTotalCount());
	}
}
2.3 Spring 整合jdbc 扩展， jdbcdaosupport  

    如果daoimpl 继承了    jdbcdaosupport  ， jdbcdaosupport 会自动读取配置文件中的

JdbcTemplate

对象， 然后我们直接调用父类的方法即可， 效果如下用super 关键字 调用父类的方法  ： 


本来我们需要把 ，dataSource 数据源放入，jdbcTempate 中， 然后把jdbctempate 注入到dao 中， 但是用了这个之后 ， 关系变了， 直接把dataSource  传入jdbcTempate 然后通过继承关系， 直接就dao 用了jdbctemapte 模板对象 ， 所以使得关系变得简单


2.4  读取properties 配置文件 

  由于， 由于程序的可拓展性， 所以用一个properties书写数据库的链接  ， 在Spring 中 properties 书写时候 ，最好加一个前缀， 因为， 有的建容易和其他的冲突， 前缀随便加， 效果如下 ： 

 

jdbc.jdbcUrl=jdbc:mysql:///hibernate
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.user=root
jdbc.password=123456

然后我们在applicationContext 引入properties 文件， 用context 标签， 需要引入context 约束的哦，然后用local host 属性， 填写地址  ，然后即可


3. springAop 事务管理

    3.1 复习 

            1.事务特性， ：acid  

                       原子性 ： 强调事务的不可分割

                        一致性： 事务执行前后数据的完整性一直 

                       隔离性 ： 一个事务的执行不受任何干扰

                        持久性： 事务一旦执行， 就永久保存进数据库 

            2. 并发问题

                    脏读，一个是事务读到了一个未提交的事务

                    不可重复读，   一个事务都到了一个已经提交的事务， 导致事务进行了两次

                      幻读， 一个事务读到了一个已经提交的insert 事务， 导致，多次查询不一致 

            3. 事务的隔离级别 

                    未提交读 : 脏读， 不可重复度，虚读有可能发生

                    已提交读： 避免脏读， 但是不可重复读，和虚读都有可能发生

                    可重复读 :  避免脏读和不可重复读 ，但是虚读都有可能发生 

                     串行化 ： 避免以上所有的问题 

mysql ： 默认是可重复读 

oracle  ： 默认是已提交

    3.2  spring  封装了管理代码 (开启事务的代码， 提交事务的代码，回滚事务的代码)

     因为不同的平台，操作的事务代码各不相同， spring 提供了一个接口 

    1.PlatformTransactionManager  接口  

    JDBCTransactionManager     jdbc  平台 实现类

    HibernateTransactionManager   hibernate 平台 实现类

注意 : 在spring 中玩事务， 最核心的对象就是TransactionManager   

       2.spring 中的管理事务的属性介绍

            事务的隔离级别

            事务是否只读（如果为只读， 就不能操作数据库中的数据）

            事务的传播行为 



3.3 事务演示

    银行转账案例 ：

         我们通过事务控制，然后让两个用户之间相互转账

注意 ： bug   我们注入的时候 ， 一定要name对着相应的配置文件才可以 

    3.2.1 使用代码进行管理事务 （这种方式很少用的 ）
dao 层：

package com.zzq.dao.impl;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

import com.zzq.dao.AccountDao;

public class AccountDaoimpl extends JdbcDaoSupport implements AccountDao {

	// 加钱
	public void increaseMoney(Integer id, Double money) {
		String sql = "update t_account set money =money+? where id=? " ; 
		this.getJdbcTemplate().update(sql, money,id); 
		
	}
            //减钱
	public void decreaseMoney(Integer id, Double money) {
		String sql = "update t_account set money =money-? where id=? " ; 
		super.getJdbcTemplate().update(sql,money,id); 
	}

	
}

  书写service 层 ： 

        

package com.zzq.service.impl;


import org.springframework.transaction.TransactionStatus;

import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

import com.zzq.dao.AccountDao;
import com.zzq.service.AccountService;

public class AccountServiceimpl implements AccountService{
   // 让dao层注入进来


	private AccountDao acc ;
	private TransactionTemplate  transactionTemplate   ;
	




	public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
		this.transactionTemplate = transactionTemplate;
	}





	public void setAcc(AccountDao acc) {
		this.acc = acc;
	}



	public void transfer(final Integer from, final Integer to, final Double money) {
		transactionTemplate.execute(new TransactionCallbackWithoutResult() {
			
	
			protected void doInTransactionWithoutResult(TransactionStatus arg0) {
				
				
				// 减少钱
				acc.decreaseMoney(from,money);
				// 加钱
				acc.increaseMoney(to, money);
				
			}
			
		}); 
		
	}



		
	
	
}

配置文件配置 ：


首先我们创建transactionmanger 事务控制核心类 事务核心类需要依赖datasource 的链接对象， 

然后创建事务模板对象

3.3.2 使用配置文件管理事务（aop）  spring为我们准备了事务通知（环绕通知）

1. 首先我们要配置通知  我们可以通过*进行匹配性的代理 事务

    

2.植入通知与切点结合 形成切面


    这里的execution 表达式， 中的*表示统配

注意 ： 一定要注入事务和dao层， 不然抛异常 提供和set 方法 进行注入


3.3.3 注解进行控制事务

通过注解

配置文件中开启注解控制事务的代码 配置这个之后  就可以用注解配置事务


@Transactional(isolation=Isolation.REPEATABLE_READ,propagation=Propagation.REQUIRED,readOnly=false)

这个注解直接放在方法的头上即可， 但是这样每个方法都要加这个注解， 显得臃肿， 因此我们可以直接写在类上


如果下面的方法有不同， 就在每个单独的方法进行加这个注解


今天的课程笔记完结 ！！！ 明天激动人心的 spring 整合 struts2  hibernate  哈哈 然后Oracle 







mybatis进阶
LP_5371的博客
06-19 235
1.Mybatis的Dao层实现 1.1 传统开发方式 1.1.1编写UserDao接口 public interface UserDao { List<User> findAll() throws IOException; } 1.1.2.编写UserDaoImpl实现 public class UserDaoImpl implements UserDao { public List<User> findAll() throws IOException { Inp
List<T> 高级进阶 实现查询功能FindAll()
热门推荐
寂寞的一只狗的博客
03-11 1万+
1.语法 1.1  List.FinAll() 1.2  ListFinAll(Predicate match) Predicate 是一个泛型委托 返回bool类型 ：public delegate bool Predicate(T obj) match 参数是一个返回bool类型的方法  由此可以定义一个泛型类，并在其中定义返回bool类型的方法，即筛选规则，最后将该方法
JavaWeb-综合案例(用户信息)-学习笔记01【列表查询】
upward
02-16 2746
JavaWeb-综合案例(用户信息)-学习笔记01【列表查询】
管理员模式查看用户列表
hq.zheng的博客
01-11 4169
1. 项目结构 2.1 com.bean package com.pojo; import java.util.Date; public class Users { private int id; private String userName; private String pwd; private int status; private int qq; privat
Spring 基于Aspectj的注解开发AOP(六)-切点命名@Ponintcut
路西法Lucifer
03-21 618
附：参考Spring 基于Aspectj的注解开发AOP(一)-前置通知 ps: 通过@Pointcut为切点命名•在每个通知内定义切点，会造成工作量大，不易维护，对于重复的切点，可以使用@Pointcut进行定义 •切点方法：private void 无参数方法，方法名为切点名 •当通知多个切点时，可以使用|| 进行连接 通俗的来说就是：如果save()方法既需要前置通知，又异...
Spring 框架 四天学习笔记_day01
Hack_ZZQ
03-29 553
1.Spring介绍    1.1spring 在项目中的位置       首先我们来看下 spring  所在项目中的位置 ssh 项目中， hibernate 负责对数据库的数据进行操作， servlice 由javabean 来控制事务， Struts2来控制web层的数据传输  ， 我们的 Spring 框架， 就像是一个盒子 ， 把 对象全部放在spring 中。1.2.Spring一站...
Spring 四天学习笔记 _day2
Hack_ZZQ
03-30 347
1. 注解配置Spring   1.1注解代替配置文件：步骤          1.为配置文件配置新的命名空间           2.开启使用注解代替配置文件           3. 在类中使用注解 完成配置（如果是新版本的spring 框架需要加上一个spring-aop-4.2.4.RELEASE.jar）               4. 因为在项目开发中 ，需要明确的分明注解所在的位置...
Spring第两天学习笔记
m0_52832310的博客
05-08 515
org.springframework spring-webmvc 5.3.9 1、spring 1.1、简介 spring：春天 ===>给软件行业带来了春天 2002年,首次推出了spring框架的雏形:interface21 Spring框架即以interface21框架为基础,经过重新设计,并不断丰富其内涵,于2004年3月24日,发布了1.0正式版。 [Rod Johnson](https://baike.baidu.com/item/Rod ...
传智博客Spring框架2016版笔记资料（四天）
08-23
这四天的课程笔记分别对应Spring_day01、Spring_day02、Spring_day03和Spring_day04四个阶段的学习内容，旨在帮助学习者快速掌握Java领域的这一关键框架。 Spring框架是Java企业级应用开发的重要支柱，它提供了一种...
Spring培训第四天学习笔记整理
标题《spring培训第四天》和描述《达内SPRING培训笔记》以及标签《spring 培训 学习 笔记》透露的信息表明，这是一份关于Spring框架的培训资料，具体是第四天的学习内容。Spring框架是一个开源的Java/Java EE全功能...
传智博客Spring框架2016版笔记资料
11-19
day03可能会转向Spring MVC，这是Spring框架中用于构建Web应用程序的一部分。这部分内容可能涵盖模型-视图-控制器（MVC）设计模式的应用，请求处理、模型数据绑定、视图解析以及自定义拦截器的编写等。此外，也可能...
黑马传智2016版Spring框架四天真传视频笔记
这些笔记文件（Spring_day01上课笔记.doc、Spring_day02上课笔记.doc、Spring_day03上课笔记.doc、Spring_day04上课笔记.doc）不仅记录了知识点，还包含了传智播客讲师的经验分享以及实际操作的案例分析，对于学习者...
Spring框架深入学习第四天视频教程
从标题“spring教学视频第四天”中可以知道，这是一个关于Spring框架教学的视频系列，第四天的内容意味着学习者已经开始了连续的课程学习，而第四天的内容是教学过程中的一个部分。Spring框架是Java平台下最常用的...
基于SpringBoot和uni-app开发的陪诊陪护软件系统源码
程序员创业中
09-06 1240
中国60岁以上人口已突破3.1亿，独居老人超1.3亿，而一线城市三甲医院日均门诊量超万人次。在这组数据背后，是无数家庭面临的困境：子女异地工作无法陪同父母就医，独居老人因不会操作智能设备在挂号机前徘徊，异地患者因不熟悉流程在医院迷路……当“就医”从个人事务演变为社会难题，陪诊陪护系统正以“专业服务+技术赋能”的双重模式，成为破解这一困局的关键。
二叉树的前中后序遍历(迭代法)
mrjieke6的博客
09-07 1149
本文系统介绍了二叉树前序、中序和后序遍历的迭代实现方法。前序遍历采用栈结构，按;根→右→左 ;顺序入栈；中序遍历先全部左子树入栈再访问节点；后序遍历则通过修改前序遍历顺序为"根→右→左 ;后反转结果。三种遍历时间复杂度均为O(n)，空间复杂度最坏O(n)。与递归实现相比，迭代方法避免了栈溢出风险，处理大型树更稳定。每种遍历方式都配有详细代码解析、执行示例和复杂度分析，并讨论了实际应用场景，为掌握树结构操作提供了系统指导。
从Java全栈开发到微服务架构的实战经验分享
CatchLight的博客
09-09 418
应聘者：我认为最重要的是能够理解业务需求，并将其转化为技术方案。同时，持续学习新技术，保持对行业趋势的关注也很关键。毕竟，技术更新很快，只有不断学习才能跟上节奏。通过这次面试，我们可以看到一位资深Java全栈开发者的专业能力和实践经验。他不仅掌握了多种技术栈，还能在实际业务场景中灵活运用，解决实际问题。同时，他也展现了良好的沟通能力和学习能力，这些都是成为一名优秀工程师的关键素质。
Android8 binder源码学习分析笔记（二）
g_i_a_o_giao的博客
09-05 2294
本文分析了Android框架中Activity启动流程涉及的Binder通信机制。通过跟踪startActivity()调用链，重点解析了客户端进程通过IApplicationThread（Binder对象）与AMS（ActivityManagerService）的跨进程通信过程：1) 客户端通过ActivityManager.getService()获取AMS的Binder代理；2) 调用AMS的startActivity方法时传入本进程的IApplicationThread对象；3) AMS通过该Bin
Java内存区域与内存溢出
DKPT的博客
09-07 555
Java内存溢出的核心在于内存分配与回收失衡，需结合区域特性针对性解决。堆溢出最常见，需重点排查泄漏；方法区溢出多因动态类加载失控；直接内存溢出则需关注NIO使用。通过工具分析+代码优化+参数调优的组合策略，可显著降低OOM风险。二、内存溢出（OOM）类型与触发场景。三、内存溢出诊断与解决策略。一、Java内存区域划分。
【lucene】bitsetiterator
最新发布
risc123456的博客
09-09 184
某些自定义 `FieldCache` 或 `DocValues` 去重逻辑，会先把出现过的 docID 记到 `BitSet`，再用 `BitSetIterator` 一次性吐出。`BitSet` 本身只有 `get()/set()/nextSetBit(int)`，没有标准的迭代器语义，于是就有了 `BitSetIterator` 做适配。- `cost()` 直接返回 `cardinality()`，方便上层 `ConjunctionDISI/DisjunctionDISI` 做排序、选 lead。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值