精华内容
下载资源
问答
  • 普通类怎么注入
    2022-04-22 13:25:55
    1、添加@Component注解
    
    2@Autowired
        private ISysDeptService iSysDeptService;
        private static A  a;  (A为你的类名) 
        
    3@PostConstruct
        public void init() {
            a= this;
        }
        
    4、调用    a.iSysDeptService.selectUserId();
    
    
    
    
    2 或者
    ISysDeptServiceImpl iSysDeptService=new ISysDeptServiceimpl();
    
    更多相关内容
  • 如何在普通类注入service 第一步: 需要在类的注解上加上@Component注解。该注解是将该类注入到service容器上 第二步: 创建一个init方法并加上一个 @PostConstruct注解,用@PostConstruct注释修饰的方法会在构造...

    如何在普通类注入service

    第一步:

    需要在类的注解上加上@Component注解。该注解是将该类注入到service容器上

    第二步:

    创建一个init方法并加上一个 @PostConstruct注解,用@PostConstruct注释修饰的方法会在构造函数之后就执行

    在这里插入图片描述

    展开全文
  • 在java web项目中,有时候我们需要将普通类注入到service 中 会用到以下的代码 ApplicationContext appContext = new ClassPathXmlApplicationContext("applicationContext-common.xml"); AbcService abcService =...

    1,applicationcontextaware 作用

    在java web项目中,有时候我们需要将普通类注入到service 中 会用到以下的代码

    ApplicationContext appContext = new ClassPathXmlApplicationContext("applicationContext-common.xml");  
    AbcService abcService = (AbcService)appContext.getBean("abcService");  
    

    这步骤会重新加载applicationContext-common.xml并实例化上下文bean。

    2,解决

    定义一个新的类,继承applicationcontextaware 重写方法。

    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    
    @Component
    public class SpringUtil implements ApplicationContextAware {
    
        private  static ApplicationContext applicationContext;
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            this.applicationContext=applicationContext;
        }
        public static ApplicationContext getApplicationContext() {
            return applicationContext;
        }
        public static Object getBean(String name) {
            return applicationContext.getBean(name);
        }
        public static <T> T getBean(Class<T> tClass) {
            return applicationContext.getBean(tClass);
        }
    }
    
    

    3,在service 层加 @Service 注解

    @Service
    public class ClusterResultServer {
    

    4,获取bean

        @Autowired
        ClusterResultServer _clusterResultServer=     (ClusterResultServer)SpringUtil.getBean(ClusterResultServer.class);
    

    欢迎关注公众号:
    在这里插入图片描述

    展开全文
  • 目录场景数据准备数据库...在一些普通的工具类或者POJO类需要注入service或者repository等spring管理的资源进行一定的逻辑处理,普通类不受spring管理,所以利用@Autowired实现不了。本文介绍几种方式解

    场景

    在一些普通的工具类或者POJO类需要注入service或者repository等spring管理的资源进行一定的逻辑处理,普通类不受spring管理,所以利用@Autowired实现不了。本文介绍几种方式解决此问题。

    本文利用老师与学生的关系作为例子讲解,一个老师可以管理多个学生,在查询老师列表时也将他名下的学生查询出来,Teacher表与Student不进行关联表处理,那么就需要在Teacher的Entity里注入StudentService进行查询。

    数据准备

    数据库

    Student

     uuid | deleted |  status  | teacher 
    ------+---------+----------+---------
     s1   |         | active   | t1
     s2   | deleted | inactive | t1
    (2 rows)
    

    Teacher

     uuid 
    ------
     t1
     t2
    (2 rows)
    
    

    Entity

    Teacher
    不同的实现方法有不同的注入,具体的参考下文
    Student

    @Data
    @Entity
    @Table(name = "student")
    @EqualsAndHashCode(of = {"id"})
    public class Student {
    
    	@Column(name = "uuid")
    	@Id
    	private String id;
    	
    	@Column(name = "deleted")
    	private String deleted;
    	
    	@Column(name = "status")
    	private String status;
    	
    	@Column(name = "teacher")
    	private String teacher;
    }
    

    Repository

    StudentReposity

    @Repository
    public interface StudentReposity extends CrudRepository<Student, String>{
    	
    	@Query("select s from Student s where s.teacher=:teacherId")
    	public Set<Student> findStudentsByTeacher(@Param("teacherId") String teacherId);
    }
    

    TeacherRepository

    @Repository
    public interface TeacherRepository extends CrudRepository<Teacher, String>{
    	@Query("select t from Teacher t")
    	public Set<Teacher> findTeachers();
    }
    

    Service

    StudentService

    @Service
    public class StudentService {
    
    	@Autowired
    	StudentReposity studentReposity;
    	
    	public Set<Student> findStudentsByTeacher(String teacherId){
    		return studentReposity.findStudentsByTeacher(teacherId);
    	}
    }
    

    TeacherService

    @Service
    public class TeacherService {
    	@Autowired
    	TeacherRepository teacherRepository;
    	
    	public Set<Teacher> findTeachers(){
    		return teacherRepository.findTeachers();
    	}
    }
    

    Controller

    @RestController
    public class TeacherController {
    
    	@Autowired
    	TeacherService teacherService;
    	
    	@GetMapping("/teachers")
    	public Set<Teacher> findTeachers(){
    		return teacherService.findTeachers();
    	}
    }
    

    解决方法

    一、利用@PostConstruct

    这种方法比较简单,但是如果你有多个Entity需要注入多个service的时候就比较麻烦一点,另外sonarqube代码检测也会有警告。
    Entity

    @Data
    @Entity
    @Table(name = "teacher")
    @EqualsAndHashCode(of = {"id"})
    public class Teacher {
    
    	@Column(name = "uuid")
    	@Id
    	private String id;
    	
    	@Transient
    	private Set<Student> students;
    	
    	public Set<Student> getStudents(){
    		return SpringBeanUtil.staticStudentService.findStudentsByTeacher(getId());
    	}
    }
    

    利用@PostConstruct

    @Component
    public class SpringBeanUtil {
    	@Autowired
    	StudentService studentService;
    	
    	public static StudentService staticStudentService;
    	
    	@PostConstruct
    	public void init() {
    		staticStudentService = studentService;
    	}
    }
    

    二、利用ENUM枚举类

    Entity

    @Data
    @Entity
    @Table(name = "teacher")
    @EqualsAndHashCode(of = {"id"})
    public class Teacher {
    
    	@Column(name = "uuid")
    	@Id
    	private String id;
    
    	@Transient
    	private Set<Student> students;
    	
    	public Set<Student> getStudents(){
    		return EnumBeanUtil.BEAN.getBean(StudentService.class).findStudentsByTeacher(getId());
    	}
    }
    
    

    定义获取ApplicatinContext的Enum

    public enum EnumBeanUtil {
    
    	BEAN;
    	
    	private ApplicationContext applicationContext;
    
    	public ApplicationContext getApplicationContext() {
    		return applicationContext;
    	}
    
    	public void setApplicationContext(ApplicationContext applicationContext) {
    		this.applicationContext = applicationContext;
    	}
    	
    	public <T> T getBean(Class<T> clazz) {
    		return getApplicationContext().getBean(clazz);
    	}
    }
    

    设置ENUM的applicationContext变量

    @SpringBootApplication
    public class Application extends SpringBootServletInitializer  {
    	
        public static void main(String[] args) {
            EnumBeanUtil.BEAN.setApplicationContext(SpringApplication.run(Application.class, args));
        }
    
    }
    

    启动测试,可以得到studnets。

    三、利用ApplicationContextAware

    Entity

    @Data
    @Entity
    @Table(name = "teacher")
    @EqualsAndHashCode(of = {"id"})
    public class Teacher {
    
    	@Column(name = "uuid")
    	@Id
    	private String id;
    	
    	@Transient
    	private Set<Student> students;
    	
    	public Set<Student> getStudents(){
    		StudentService studentService = BeanUtil.getBean(StudentService.class);
    		return studentService.findStudentsByTeacher(getId());
    	}
    }
    

    1、实现ApplicationContextAware接口

    @Component
    public class BeanUtil implements ApplicationContextAware{
    
        //@note
    	private static ApplicationContext context;
    	
    	@Override
    	public void setApplicationContext(ApplicationContext applicationContext) {
    		BeanUtil.context = applicationContext;
    	}
    	
    	public static <T> T getBean(Class<T> beanClass) {
            return context.getBean(beanClass);
        }
    
    }
    

    @note: 如果你的代码有sonarqube检查的话会有critical的警告,所以如果你有严格的代码规范的话这种方法不推荐。

    测试

    发起/teachers请求可得到结果:

    [
        {
            "id": "t1",
            "students": [
                {
                    "id": "s1",
                    "deleted": null,
                    "status": "active",
                    "teacher": "t1"
                },
                {
                    "id": "s2",
                    "deleted": "deleted",
                    "status": "inactive",
                    "teacher": "t1"
                }
            ]
        },
        {
            "id": "t2",
            "students": []
        }
    ]
    

    可以看到students查出来,证明StudnetService确实被注入进去了。

    四、利用Hibernate Interceptor

    Entity

    @Data
    @Entity
    @Table(name = "teacher")
    @EqualsAndHashCode(of = {"id"})
    public class Teacher {
    
    	@Column(name = "uuid")
    	@Id
    	private String id;
    
    	@Transient
    	private Set<Student> students;
    	
    	@Transient
    	@JsonIgnore
    	private StudentService studentService;
    	
    	public Set<Student> getStudents(){
    		return studentService.findStudentsByTeacher(getId());
    	}
    }
    

    1、创建自己的Interceptor并扩展EmptyInterceptor

    public class StudentInterceptor extends EmptyInterceptor{
    
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = -4771865788342461458L;
    
    	@Autowired
    	@Lazy //@note1
    	StudentService studentService;
    	
    	//@note2
    	@Override
    	public boolean onLoad(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types) {
    	    //@note3
    		if(entity instanceof Teacher) {
    			((Teacher) entity).setStudentService(studentService);
    			return true;
    		}
    		return false;
    	}
    }
    

    @note1: 懒加载防止启动的时候出现bean加载死循环
    @note2:重写onLoad方法,在对象加载的时候就注入service。
    @note3: 对象是Teacher的注入studentService。如果对象多可以在这里添加自己的需求。

    2、实例化自定义的Interceptor
    如果是注解方式配置的话:

    @Configuration
    @EnableTransactionManagement
    @EnableJpaRepositories(entityManagerFactoryRef = "entityManagerFactory"
    						, basePackages = { "***.your.repository" })
    public class PersistenceConfiguration {
    
    	@Primary
    	@Bean(name = "entityManagerFactory")
    	public LocalContainerEntityManagerFactoryBean entityManagerFactory(EntityManagerFactoryBuilder builder,
    			@Qualifier("dataSource") DataSource dataSource) {
    		//@note
    		Map<String, Object> jpaProperties = new HashMap<>();
    		jpaProperties.put("hibernate.ejb.interceptor", studentInterceptor());
    		return builder.properties(jpaProperties)
    		//your other configuration
    		.build();
    	}
    	
    	@Bean
    	public StudentInterceptor studentInterceptor() {
    		return new StudentInterceptor();
    	}
        
        //other configuration
    }
    

    如果你的Spring boot版本号小于2,可以通过extends HibernateJpaAutoConfiguration 来实现,具体做法参考link.其他做法也可以参考该文章,但是我本人测都实现不了。

    测试

    发起/teachers请求可得到结果:

    [
        {
            "id": "t1",
            "students": [
                {
                    "id": "s1",
                    "deleted": null,
                    "status": "active",
                    "teacher": "t1"
                },
                {
                    "id": "s2",
                    "deleted": "deleted",
                    "status": "inactive",
                    "teacher": "t1"
                }
            ]
        },
        {
            "id": "t2",
            "students": []
        }
    ]
    

    可以看到students查出来,证明StudnetService确实被注入进去了。

    五、利用AOP Injection

    Entity
    声明注解@Configurable、@Aspect。

    @Data
    @Entity
    @Table(name = "teacher")
    @EqualsAndHashCode(of = {"id"})
    @Configurable
    @Aspect
    public class Teacher {
    
    	@Column(name = "uuid")
    	@Id
    	private String id;
    	
    	@Transient
    	private Set<Student> students;
    	
    	@Transient
    	@JsonIgnore
    	@Autowired
    	private StudentService studentService;
    	
    	public Set<Student> getStudents(){
    		return studentService.findStudentsByTeacher(getId());
    	}
    }
    

    1、告诉spring激活aop injection

    @SpringBootApplication
    @EnableSpringConfigured  //@note。通知spring
    public class Application extends SpringBootServletInitializer  {
    	
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    
    }
    

    2、使用AspectJ “Java Agent”
    如果你是使用Eclipse,可以在Debug Configurations->Arguments->VM arguments添加==-javaagent:\your\path\to\aspectjweaver.jar==。需要下载aspectjweaver依赖。
    如果你是直接打好包,则可执行java -jar your.jar -javaagent:\your\path\to\aspectjweaver.jar。

    如果你是xml配置的话可以参考这篇文章.

    要实现AOP可能还需要导入一些依赖:

    <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-aop -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
        <version>2.2.6.RELEASE</version>
    </dependency>
    

    如果你还有其他方法,欢迎讨论*-*

    参考:

    https://blog.csdn.net/qq_39056805/article/details/80285915

    https://blog.csdn.net/Mrs_chens/article/details/93741730

    https://stackoverflow.com/questions/9666922/enable-spring-aop-or-aspectj

    https://dzone.com/articles/inject-spring-beans-aspectj

    https://stackoverflow.com/questions/27744287/what-is-the-spring-java-config-equivalent-of-contextspring-configured

    https://stackoverflow.com/questions/10008714/requested-bean-is-currently-in-creation-is-there-an-unresolvable-circular-refer

    https://stackoverflow.com/questions/25283767/how-to-use-spring-managed-hibernate-interceptors-in-spring-boot/29919009

    http://jblewitt.com/blog/?p=129

    展开全文
  •  找了很多的方法,无论是@Component 还是编写普通类实现编写工具类实现ApplicationContextAware,都获取不到,最后实现方法如下: ApplicationContext ctx = new ClassPathXmlApplicationContext("../../WEB...
  • 解决办法:通过一个spring工具搞定 @Component public class SpringUtilsAuTo implements BeanFactoryPostProcessor { /** * Spring应用上下文环境 */ private static ConfigurableListableBeanFactory ...
  • 场景:使用Quartz定时器时,普通的java需要注入spring的service,在调用时报错! 解决方式: /** * 定时获取课程的service */ @Autowired protected QuartzGetCourseService quartzGetCourseService = ...
  • 普通类注入service层和dao层

    千次阅读 2018-10-11 09:45:33
    1,写一个工具SpringTool: package com.zhiyu.util; import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context....
  • springboot普通java类注入service

    千次阅读 2019-03-25 17:42:25
    工具代码如下: import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org....
  • 需要自定义方法: ... import org.springframework.beans.BeansException; import org.springframework.beans.factory.NoSuchBeanDefinitionException; import org.springframework.context.ApplicationContext;...
  • 为了让导入功能和业务逻辑分开,就把这个导入功能做成一个独立的Util工具. ** 问题描述 把导入功能和业务逻辑分开后,所遇到的问题就是,这个导入功能需要依赖其他的资源,按照一般的注解方法肯定是行不通了,那么,...
  • 1.创建工具 package com.jeesite.modules.sys.utils; import com.jeesite.modules.sys.service.CardLoginUsersService; import com.jeesite.modules.sys.service.UserService; import org.springframework....
  • 使用quartz做定时任务,任务需要定时到数据库查询,向查到记录的用户发送信息,因涉及到数据库查询,需要...* 获取spring上下文里的bean,方便在普通类里也可以使用 * @author Administrator * */ @Component //注...
  • } 但是我们要使用 ZkConfig 的地方是一个普通类 ZkManager,它没有 @controller 、@service、@repository 注解,也就不会被 spring 容器自动初始化。 如果在 ZkManager 中使用下面代码,然后 new ZkManager(),可以...
  • 场景:在普通类或枚举类中,需要调用service,查数据库等; 示例代码: public class XXX { private static testService test = null; @Component public static class GetService{ @Autowired ...
  • java普通类注入service或mapper

    千次阅读 2020-04-27 16:14:49
    加@Component注解 注入需要引入的service @Autowired private UserService userService; 建静态文件 private static UserService users; 初始化方法 @PostConstruct public void init() { users= ...
  • SpringBoot项目将Bean注入普通类

    千次阅读 2020-01-03 09:25:28
    SpringBoot项目将Bean注入普通类中Spring管理的类获得一个注入的Bean方式非Spring管理的类获得一个注入的Bean方式普通类中通过ApplicationContext上下文获得Bean修改SpringBoot启动类,将ApplicationContext传入...
  • Java普通类注入service对象

    千次阅读 2018-02-01 16:31:04
    找了很多办法,无论是加@Component还是编写工具实现ApplicationContextAware,始终为null。 最后使用这两行代码解决: WebApplicationContext context = ContextLoader.getCurrentWebApplicationContext(); ...
  • 在Spring中,我们会在Controller层使用自动注入的Service层,在Service层使用自动注入的Dao层,如果想在普通中使用自动注入Service或者是Dao层时,可以这样做: 1、在相应的上加上@Component注解 @Component...
  • 普通类中使用Spring注入

    千次阅读 2017-06-02 16:58:35
    在编写工具类 提供方法的时候由于要注入service层,在编写的时候发现service层类注入失败,由于普通类不是通过spring进行管理的,所有注入service会失败。所以可以采用下面的方法。SpringTool需要加到spring配置中,...
  • 指明这是个插件,好被Spring注入到容器中 public class PublicController{ @Autowired private ConfigUtil configUtil; @Autowired private RedisTemplate redisTemplate; // 在注入时候会清空此类对象,先...
  • 在springboot框架中,如果我们如果直接向controller或者serviceImpl层注入接口是可以直接注入的,但是如果向普通类直接注入接口是注入不进去的。 我们通过@PostConstruct这个注解来解决 被这个注解 标记的方法 ...
  • 在给项目写一个定时器的时候,需要用到注入mapper进行数据库操作,用像serviceimpl里的注入 @Autowired  UserMapper usermapper; 无效,debug后发现usemapper为null,说明没有注入成功后看到...
  • 普通类类似一个工具类,上传excel时验证对应字段是否符合规则,主要是规则判断会依据不同条件进行不同逻辑处理,但是这个条件需要从另一个类的方法获取,无法注入这个类,意味着无法获取其方法。 猜想: 一般的...
  • 一、使用工具实现ApplicationContextAware获取ApplicationContenxt,再用ApplicationContenxt获取Spring容器中的bean package com.ats.utils; import org.springframework.beans.BeansException; import org....
  • 我使用的是springboot+...1.创建一个SpringUtil工具 import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.Applic...
  • 但是在普通Java类中使用service或者dao就会报空指针异常,因为这个普通类不在Spring的管理下,所以不能使用Spring来注入。 下面讲一下一个普通的Java类如何使用service 先定义SpringContextHolder package ...
  • spring如何对普通类进行注入

    千次阅读 2016-04-21 18:21:23
    spring如何对普通类进行注入  分享| 2009-05-12 22:3710806080 | 浏览 3514 次  编程语言 class="dao.impl.xardDaoImpl"> class="service.impl.xardServiceIm

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 115,377
精华内容 46,150
关键字:

普通类怎么注入