import virtuoso.sesame2.driver.VirtuosoRepository; //导入依赖的package包/类
@Override
public synchronized Sail getSail() throws SailException {
	if (repository == null) {
		try {
			virtuoso = new VirtuosoRepository("jdbc:virtuoso://localhost:1111", "dba", "dba", true);
			repository = new RepositorySail(virtuoso);
			
			// Needed for inferencing...
			URL schema = Thread.currentThread().getContextClassLoader().getResource("/org/waag/ah/rdf/schema/artsholland.rdf");
			RepositoryConnection connection = virtuoso.getConnection();
			connection.add(schema, null, RDFFormat.RDFXML);
			virtuoso.createRuleSet("artsholland", "http://purl.org/artsholland/1.0/");
			connection.close();
			
		} catch (Exception e) {
			throw new SailException(e);
		}
	}
	return repository;
}
 

import virtuoso.sesame2.driver.VirtuosoRepository; //导入依赖的package包/类
public VirtuosoRepositoryManager(String repositoryUrl, String port, String username, String password) throws RepositoryConnectionException{
    logger.debug("Connecting to Virtuoso["+repositoryUrl+","+port+","+username+","+password+"]");
    if(repositoryUrl.startsWith(Resources.defaultUrlPrefix)){
            repositoryUrl=repositoryUrl.replace(Resources.defaultUrlPrefix, "");
        }
    if(repositoryUrl.endsWith("/")){
        repositoryUrl=repositoryUrl.substring(0, repositoryUrl.length()-1); 
    }
    this.repo=new VirtuosoRepository(Resources.defaultVirtuosoJdbcUrlPrefix+repositoryUrl+":"+port, username, password);
    /*Connect to check that everything is allright */
    try{
        RepositoryConnection repoConn=this.repo.getConnection();
        repoConn.close();
    }catch(RepositoryException ex){
        throw new RepositoryConnectionException("An error occured while initializing the connection to the repository",ex);
    }
}
 

import virtuoso.sesame2.driver.VirtuosoRepository; //导入依赖的package包/类
private Repository createVirtuosoRepository(String name, OutputParamReader paramReader) throws LDFusionToolException {
    String host = paramReader.getRequiredStringValue(ConfigParameters.DATA_SOURCE_VIRTUOSO_HOST);
    String port = paramReader.getRequiredStringValue(ConfigParameters.DATA_SOURCE_VIRTUOSO_PORT);
    String username = paramReader.getStringValue(ConfigParameters.DATA_SOURCE_VIRTUOSO_USERNAME);
    String password = paramReader.getStringValue(ConfigParameters.DATA_SOURCE_VIRTUOSO_PASSWORD);

    String connectionString = LDFusionToolUtils.getVirtuosoConnectionString(host, port);
    Repository repository = new VirtuosoRepository(connectionString, username, password);
    try {
        repository.initialize();
    } catch (RepositoryException e) {
        throw new LDFusionToolApplicationException(LDFusionToolErrorCodes.REPOSITORY_INIT_VIRTUOSO,
                "Error when initializing repository for " + name, e);
    }

    LOG.debug("Initialized Virtuoso repository {}", name);
    return repository;
}
 

import virtuoso.sesame2.driver.VirtuosoRepository; //导入依赖的package包/类
public static void main(String[] args) {

		String[] sa = new String[4];
		sa[0] = VIRTUOSO_INSTANCE;
		sa[1] = VIRTUOSO_PORT + "";
		sa[2] = VIRTUOSO_USERNAME;
		sa[3] = VIRTUOSO_PASSWORD;
		for (int i = 0; i < sa.length && i < args.length; i++) {
			sa[i] = args[i];
		}
		Repository repository = new VirtuosoRepository("jdbc:virtuoso://" + sa[0] + ":" + 
				sa[1]+ "/charset=UTF-8/log_enable=2", sa[2], sa[3]);

		//		extractObjectProperties(repository, "http://europeana.eu", Params.LOD_OBJECT_PROPERIES_FILE);
		//		extractDataProperties(repository, "http://europeana.eu", Params.LOD_DATA_PROPERIES_FILE);

		//		extractObjectProperties(repository, "http://amsterdammuseum.nl", Params.LOD_OBJECT_PROPERIES_FILE);
		//		extractDataProperties(repository, "http://amsterdammuseum.nl", Params.LOD_DATA_PROPERIES_FILE);

		List<String> graphIRIs = new ArrayList<String>();
		graphIRIs.add("http://musicbrainz.org");
		graphIRIs.add("http://dbtune.org/jamendo");
		graphIRIs.add("http://dbtune.org/magnatune");
		graphIRIs.add("http://dbtune.org/bbc/peel");
		graphIRIs.add("http://dbtune.org/bbc/playcount");
		extractDataProperties(repository, graphIRIs, Params.LOD_DATA_PROPERIES_FILE);
		extractObjectProperties(repository, graphIRIs, Params.LOD_OBJECT_PROPERIES_FILE);

	}
 

import virtuoso.sesame2.driver.VirtuosoRepository; //导入依赖的package包/类
/**
 * Create the store provided by this SailProvider
 *
 * @return a new instance of the store
 */
@Override
public NotifyingSail createStore() {
    final String host = configurationService.getStringConfiguration("virtuoso.host", "localhost");
    final int port = configurationService.getIntConfiguration("virtuoso.port", 1111);
    final String user = configurationService.getStringConfiguration("virtuoso.user", "dba");
    final String pass = configurationService.getStringConfiguration("virtuoso.pass", "dba");
    final String connString = "jdbc:virtuoso://"+host+":"+port;
    
    log.info("Initializing Backend: Virtuoso Store, over " + connString + "...");
    VirtuosoRepository repository = new VirtuosoRepository(connString, user, pass);
    return new NotifyingSailWrapper(repository);
}
 

import virtuoso.sesame2.driver.VirtuosoRepository; //导入依赖的package包/类
@Override
protected void configureInternal(VirtuosoExtractorConfig config) throws ConfigurationException {
    String connectionString = "jdbc:virtuoso://" + config.getHost() + ':' + config.getPort();
    repository = new VirtuosoRepository(connectionString, config.getUserName(), config.getPassword(), true);
    ValueFactory valueFactory = repository.getValueFactory();
    if (config.getGraph() != null)
        graph = valueFactory.createURI(config.getGraph());
    if (config.getSubject() != null)
        subject = valueFactory.createURI(config.getSubject());
    if (config.getPredicate() != null)
        predicate = valueFactory.createURI(config.getPredicate());
}
 

import virtuoso.sesame2.driver.VirtuosoRepository; //导入依赖的package包/类
public ValueLoader(String host, String port, String user, String pwd) {
    String connectionString = "jdbc:virtuoso://" + host + ':' + port;
    repository = new VirtuosoRepository(connectionString, user, pwd, true);
    try {
        RepositoryConnection con = repository.getConnection();
        con.close();
    } catch (RepositoryException e) {
        throw new IllegalArgumentException(e.getMessage(),e);
    }
}
 

import virtuoso.sesame2.driver.VirtuosoRepository; //导入依赖的package包/类
/**
 * Creates a new instance based the supplied complete set of configuration properties.
 * 
 * @param fileSystem
 *            the file system where to store the marker file
 * @param host
 *            the name / IP address of the host where virtuoso is running; if null defaults to
 *            localhost
 * @param port
 *            the port Virtuoso is listening to; if null defaults to 1111
 * @param username
 *            the username to login into Virtuoso; if null defaults to dba
 * @param password
 *            the password to login into Virtuoso; if null default to dba
 * @param pooling
 *            true if connection pooling should be used (impact on performances is
 *            negligible); if null defaults to false
 * @param batchSize
 *            the number of added/removed triples to buffer on the client before sending them
 *            to Virtuoso as a single chunk; if null defaults to 5000
 * @param fetchSize
 *            the number of results (solutions, triples, ...) to fetch from Virtuoso in a
 *            single operation when query results are iterated; if null defaults to 200
 * @param markerFilename
 *            the name of the marker file created to signal Virtuoso is being used in a
 *            non-transactional mode; if null defaults to virtuoso.bulk.transaction
 */
public VirtuosoTripleStore(final FileSystem fileSystem, @Nullable final String host,
        @Nullable final Integer port, @Nullable final String username,
        @Nullable final String password, @Nullable final Boolean pooling,
        @Nullable final Integer batchSize, @Nullable final Integer fetchSize,
        @Nullable final String markerFilename) {

    // Apply default values
    final String actualMarkerFilename = MoreObjects.firstNonNull(markerFilename,
            DEFAULT_MARKER_FILENAME);
    final String actualHost = MoreObjects.firstNonNull(host, DEFAULT_HOST);
    final int actualPort = MoreObjects.firstNonNull(port, DEFAULT_PORT);
    final String actualUsername = MoreObjects.firstNonNull(username, DEFAULT_USERNAME);
    final String actualPassword = MoreObjects.firstNonNull(password, DEFAULT_PASSWORD);
    final boolean actualPooling = MoreObjects.firstNonNull(pooling, DEFAULT_POOLING);
    final int actualBatchSize = MoreObjects.firstNonNull(batchSize, DEFAULT_BATCH_SIZE);
    final int actualFetchSize = MoreObjects.firstNonNull(fetchSize, DEFAULT_FETCH_SIZE);

    // Check parameters
    Preconditions.checkArgument(actualPort > 0 && actualPort < 65536);
    Preconditions.checkArgument(actualBatchSize > 0);
    Preconditions.checkArgument(actualFetchSize > 0);

    // Instantiate the VirtuosoRepository
    if (actualPooling) {
        // Pooling (see http://docs.openlinksw.com/virtuoso/VirtuosoDriverJDBC.html, section
        // 7.4.4.2) doesn't seem to affect performances. We keep this implementation: perhaps
        // things may change with future versions of Virtuoso.
        final VirtuosoConnectionPoolDataSource source = new VirtuosoConnectionPoolDataSource();
        source.setServerName(actualHost);
        source.setPortNumber(actualPort);
        source.setUser(actualUsername);
        source.setPassword(actualPassword);
        this.virtuoso = new VirtuosoRepository((ConnectionPoolDataSource) source,
                "sesame:nil", true);
    } else {
        final String url = String.format("jdbc:virtuoso://%s:%d", actualHost, actualPort);
        this.virtuoso = new VirtuosoRepository(url, actualUsername, actualPassword,
                "sesame:nil", true);
    }

    // Further configure the VirtuosoRepository
    this.virtuoso.setBatchSize(actualBatchSize);
    this.virtuoso.setFetchSize(actualFetchSize);

    // Setup marker variables
    this.fileSystem = Preconditions.checkNotNull(fileSystem);
    this.markerPath = new Path(actualMarkerFilename).makeQualified(fileSystem);

    // Log relevant information
    LOGGER.info("VirtuosoTripleStore URL: {}", actualHost + ":" + actualPort);
    LOGGER.info("VirtuosoTripleStore marker: {}", this.markerPath);
}
 

import virtuoso.sesame2.driver.VirtuosoRepository; //导入依赖的package包/类
VirtuosoRepository getVirtuoso() {
    return this.virtuoso;
}