Question

我的问题是 - 我可以在多个类中自动装配一个类的实例吗？

我的应用程序使用Spring MVC在JSP前端页面和MongoDB后端之间进行通信。我正在使用MongoDB作为我的存储库。我创建了一个服务，为MongoDB执行CRUD方法。下面可以看到一种CRUD方法（并非所有方法都显示为不需要）。它使用Mongo模板。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class SensorReadingService {

@Autowired
private MongoTemplate mongoTemplate;

/**
 * Create a unique mongo id and insert the document into
 * the collection specified. If collection doesn't exist, 
 * create it.
 * @param sensor
 */ 
public void addSensorReadingIntoCollection(SensorReading sensor, String collection)  {
    if (!mongoTemplate.collectionExists(SensorReading.class)) {
        mongoTemplate.createCollection(SensorReading.class);
    }

    String id = UUID.randomUUID().toString();

    String[] ids = id.split("-");

    String noHyphens = "";

    for(int i = 0; i<ids.length; i++) {
        noHyphens = noHyphens.concat(ids[i]);
    }

    sensor.setId(noHyphens);
    mongoTemplate.insert(sensor, collection);
}

可以看出，MongoTemplate是自动装配的。在我的Dispatcher-Servlet中，我有以下MongoDB代码：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:p="http://www.springframework.org/schema/p"
   xsi:schemaLocation="
   http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.2.xsd
   http://www.springframework.org/schema/mvc 
   http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

<context:component-scan base-package="usm" />

<!-- Factory bean that creates the Mongo instance -->
<bean id="mongo" class="org.springframework.data.mongodb.core.MongoFactoryBean">
    <property name="host" value="localhost" />
</bean>

<!-- MongoTemplate for connecting and querying the documents in the database -->
<bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
    <constructor-arg name="mongo" ref="mongo" />
    <constructor-arg name="databaseName" value="USMdb" />
</bean>

<!-- Use this post processor to translate any MongoExceptions thrown in @Repository annotated classes -->
<bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />   

<bean id="jspViewResolver"
      class="org.springframework.web.servlet.view.InternalResourceViewResolver"
      p:prefix="/WEB-INF/jsp/"
      p:suffix=".jsp" />    

<mvc:resources mapping="/resources/**" location="/resources/" />

<mvc:annotation-driven />

我现在还有一个自动装配服务的控制器，以便JSP页面的请求可以传递给控制器，然后控制器通过自动服务将这些请求写入数据库。（下面显示的一个示例方法是类很大）。这个自动服务的服务在调度程序servlet中没有像之前自动装配的MongoDB一样。

import gnu.io.SerialPortEventListener;
import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

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

@Controller
public class SensorReadingController implements SerialPortEventListener {

//mongodb service
@Autowired
private SensorReadingService sensorReadingService;

    /**
 * When a post method is achieved via save, check if reading already
 * exists and update. Else, create new sensor. Redirect back to post race
 * page.
 * @param sensorReading
 * @param model
 * @return post race page
 */
@RequestMapping(value = "/postRace-save", method = RequestMethod.POST)
public View createSensorReading(@ModelAttribute SensorReading sensor, ModelMap model,@RequestParam(value="colName", required=true)String name) {
    if (StringUtils.hasText(sensor.getId())) {
        sensorReadingService.updateSensorReading(sensor, name);
    }
    else {
        sensorReadingService.addSensorReading(sensor);
    }
    return new RedirectView("/USM-Analysis-Application/postRace");
}

sensorReadingService方法运行完美，在数据库上执行CRUD方法。 现在我的问题是，如何在另一个类中使用此sensorReadingService？当我添加

时

//mongodb service
@Autowired
private SensorReadingService sensorReadingService;

进入另一个班级，该服务并不起作用。没有错误被抛出，服务只是不向数据库添加任何东西。是因为@Autowired只允许在一个类中自动装配类，即不能有多个实例？或者是因为我没有像MongoDB那样在我的调度程序servlet中指定任何内容？

我需要让它在另一个类中工作的原因是，在我的课堂上，我正在收听串行事件。当有数据可用时，我创建一个新线程来处理这个串行事件，这样我的程序的其余部分仍然可以运行。在线程中，我解析从Serial收到的字符串，创建一个新的SensorReading对象，然后我想将此SensorReading对象写入数据库。但是，因为我无法让sensorReadingService在任何其他类中工作，所以我无法对数据库执行此写操作。

首先，我使用了一个实现Runnable的类来执行解析和保存。在这个类中使用@Autowired不起作用，所以我尝试将sensorReadingService传递给来自控制器的线程（如下面的代码所示）。这也不起作用。然后我改变了我的线程以实现Callable，所以我可以返回SensorReading并将其保存到我的原始控制器类中具有工作自动服务的数据库中。但是，这首先打败了创建线程的目的，因为它是写入我想在线程中执行的数据库，因为如果没有，它会减慢整个程序的速度。

 @Override
public void serialEvent(SerialPortEvent oEvent) {
    if (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {          
        //use a thread in the thread pool
       //tried passing sensorReadingService to thread but did not work
        //threadPool.execute(new RealTimeThread(input, sensorReadingService, getRealTimeIdsAndNames()));

        //tried return sensor reading. This works but slows down the program.
        Callable<List<SensorReading>> callable = new RealTimeThread(input, getRealTimeIdsAndNames(), offset, sensitivity);
        Future<List<SensorReading>> future = threadPool.submit(callable);

所以，我只是想知道是否有人知道我在@Autowired做错了什么？ 我可以拥有多个@Autowired实例吗？我是否需要在我的调度程序servlet中添加一些内容？或者我应该不使用@Autowired并尝试以另一种方式调用我的服务？

任何建议都将非常感谢，如果您需要我发布更多代码，请告诉我们！提前致谢！

修改

对于我的RealTimeThread类，我有以下代码

import org.springframework.beans.factory.annotation.Autowired;
import usm.service.SensorReadingService;

 public class RealTimeThread implements Callable<List<SensorReading>> {

//mongodb service
@Autowired
private SensorReadingService sensorReadingService;

//fed by an InputStreamReader to convert bytes to strings
BufferedReader input;

//variables for getting data from real time
ArrayList<Byte> values = new ArrayList<Byte>();
//mappings for sensors
double[] offset;
double[] sensitivity;

Map<String, String> realTimeIDs;

public RealTimeThread(BufferedReader input, Map<String, String> rt, double[] offset, double[] sens) {
    this.input = input;
    realTimeIDs = rt;
    this.offset = offset;
    this.sensitivity = sens;
}

//Split up the line, parse it and add to database
@Override
public List<SensorReading> call() throws Exception {
    List<SensorReading> toReturn = new ArrayList<SensorReading>();

        String inputLine;
        if((inputLine = input.readLine()) != null) {

            //pass to the scanner
            Scanner scan = new Scanner(inputLine); 

            //get everything after the starting pattern 
            Pattern pStart = Pattern.compile("\\x02\\x02\\x02\\x02\\x02(.*)"); 
            Matcher mStart = pStart.matcher(inputLine);
            if ( mStart.find() ) {
               inputLine = mStart.group(1);

               //get everything before ending pattern
               Pattern pEnd = Pattern.compile("(.*)\\x04\\x04\\x04\\x04\\x04"); 
               Matcher mEnd = pEnd.matcher(inputLine);
               if ( mEnd.find() ) {
                   inputLine = mEnd.group(1); // " that is awesome"

                   //split up this string
                   scan = new Scanner(inputLine);

                   //set the delimiter to unit separator
                   Pattern delim = Pattern.compile("\\x1F"); 
                   scan.useDelimiter(delim); 

                   while(scan.hasNext()) {
                       //get the next string
                       String s = scan.next();

                       //change it to an integer and make it a byte
                       int val = Integer.parseInt(s);
                       byte b = (byte) val;

                       //add to the arraylist
                       values.add(b);
                   } 

                   //parse the values
                   toReturn = parser(values);

                  // System.out.println("RETURN 0 " + toReturn.get(1).getRawValue());

                   //reset the arraylist
                   values = new ArrayList<Byte>();
                }                  
            }
        }

    return toReturn;
}

//Parser to split up line, create a new sensor reading and add to database
private List<SensorReading> parser(ArrayList<Byte> data) {

    //arraylist for data after transformation
    ArrayList<Short> convertedData = new ArrayList<Short>();

    //get all data in big endian 
    for (int i = 0; i<46; i=i+2) {

    ...
...
        convertedData.add(dataChunk);
    }

    //get the time now
    double myTime = System.currentTimeMillis();

    ArrayList<SensorReading> toReturn = new ArrayList<SensorReading>();

//add to the database
    for(int i = 0; i<convertedData.size(); i++) {
        //create new sensor reading
        SensorReading sr = new SensorReading();
        sr.setSensorId(keys[i].toString());
        sr.setName(sens.get(keys[i]));
        sr.setRawValue(convertedData.get(i));
        sr.setTime(myTime);

        //add to database - this is not working 
        sensorReadingService.addSensorReadingIntoCollection(sr, "realTime");
        System.out.println("added");

        toReturn.add(sr);
    }

    return toReturn;
}
}

当尝试在我的XML或使用@Component创建bean时，我得到一个BeanCreationException，表示没有默认的空构造函数。我有一个构造函数，但它有输入。 如何让Spring使用此构造函数？

我尝试在我拥有的构造函数上使用@Autowired，但我收到一条错误消息，说它无法自动装配字段BufferedInput。有什么建议？谢谢！

修改

我在我的RealTimeThread类上使用了@Component，在我的构造函数上使用了@Autowired。现在我得到的错误如下：

[localhost-startStop-1] ERROR org.springframework.web.context.ContextLoader - Context
initialization failed
org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'realTimeThread' defined in file [C:\Users\Lauren\Dropbox\MEng Project\1. Off-board Software\Lauren\.metadata\.plugins\org.eclipse.wst.server.core\tmp1\wtpwebapps\USM-Analysis-Application\WEB-INF\classes\usm\model\RealTimeThread.class]: Unsatisfied dependency expressed through constructor argument with index 0 of type [java.io.BufferedReader]: : No qualifying bean of type [java.io.BufferedReader] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {}; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [java.io.BufferedReader] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {}

所以我从中收集到的是我的BufferedReader不是由Spring处理的？我从我的Controller类传递我的BufferedReader，如下所示：

@Controller
public class SensorReadingController implements SerialPortEventListener {

//mongodb service
@Autowired
private SensorReadingService sensorReadingService;

private BufferedReader input;
double[] offset;
double[] sensitivity;

...

@Override
public void serialEvent(SerialPortEvent oEvent) {
    if (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE) {          
        //use a thread in the thread pool
        //threadPool.execute(new RealTimeThread(input, sensorReadingService, getRealTimeIdsAndNames()));

        //input.readLine();

        Callable<List<SensorReading>> callable = new RealTimeThread(input, getRealTimeIdsAndNames(), offset, sensitivity);
        Future<List<SensorReading>> future = threadPool.submit(callable);

我认为，因为我是从控制器传递这些变量，所以Spring已经处理过了。但我猜不是。 如何让Spring管理这些变量？我是否只是像使用我的服务一样使用@Autowired？

Answer 1

问题似乎是SensorReadingService被自动装入的类不是由Spring管理的类。要使自动装配工作，需要接线的类需要具有由Spring管理的生命周期（这意味着您需要在Spring Java Config的Spring XML中为该类创建一个条目）

您可以像这样重构代码：

1）向RealTimeThread添加另一个构造函数参数，该参数将是SensorReadingService类型。

2）像这样创建一个类RealTimeThreadFactory：

public class RealTimeThreadFactory {

    private final SensorReadingService sensorReadingService;

    public RealTimeThreadFactory(SensorReadingService sensorReadingService) {
        this.sensorReadingService = sensorReadingService;
    }

    public RealTimeThread getObject(BufferedReader input, Map<String, String> rt, double[] offset, double[] sens) {
          return new RealTimeThread(input, rt, offset, sens, sensorReadingService);
    }
}

3）在组件扫描中包含的包下的某处添加Java Config类

@Configuration
public class RealTimeThreadConfig {

    @Autowired
    private SensorReadingService sensorReadingService;

    @Bean
    public RealTimeThreadFactory realTimeThreadFactory() {
        RealTimeThreadFactory realTimeThreadFactory = new RealTimeThreadFactory(sensorReadingService);
        return realTimeThreadFactory;
    }

}

4）使用当前代码创建RealTimeThread的类现在需要是一个Spring bean（使用您喜欢的任何方式）并注入RealTimeThreadFactory。为了创建RealTimeThread对象，只需使用适当的参数调用工厂上的getObject（）方法

我可以在多个类中使用Spring @Autowired吗？

1 个答案: