cfspider/JavaLoaderFactory.cfc at main · robertz/cfspider · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
/*
Title:      JavaLoaderFactory.cfc

Source:     https://github.com/jamiekrug/JavaLoaderFactory

Author:     Jamie Krug
            http://identi.ca/jamiekrug
            http://twitter.com/jamiekrug
            http://jamiekrug.com/blog/

Purpose:    Factory to provide facade to server-scoped instance of
            JavaLoader (http://javaloader.riaforge.org/).

Example ColdSpring bean factory configuration:

	<bean id="javaLoaderFactory" class="JavaLoaderFactory.JavaLoaderFactory" />

	<bean id="javaLoader" factory-bean="javaLoaderFactory" factory-method="getJavaLoader">
		<constructor-arg name="loadPaths">
			<list>
				<value>/opt/XOM/xom-1.2.6.jar</value>
			</list>
		</constructor-arg>
		<constructor-arg name="loadRelativePaths">
			<list>
				<value>/../jars/opencsv-2.2.jar</value>
			</list>
		</constructor-arg>
	</bean>

Example usage:

	javaLoader = getBeanFactory().getBean( 'javaLoader' );

	csvReader = javaLoader.create( 'au.com.bytecode.opencsv.CSVReader' );

*/
component hint="Factory to provide facade to server instance of JavaLoader." {

    /********** CONSTRUCTOR ***************************************************/

    function init(numeric lockTimeout = 60, string serverKey) {
        variables.lockTimeout = arguments.lockTimeout;

        if (structKeyExists(arguments, 'serverKey')) variables.serverKey = arguments.serverKey;

        return this;
    }


    /********** PUBLIC ********************************************************/


    function getJavaLoader(
        array loadPaths,
        boolean loadColdFusionClassPath,
        string parentClassLoader,
        array sourceDirectories,
        string compileDirectory,
        boolean trustedSource,
        array loadRelativePaths
    ) {
        var javaLoaderInitArgs = buildJavaLoaderInitArgs(argumentCollection = arguments);

        var _serverKey = calculateServerKey(javaLoaderInitArgs);

        if (!structKeyExists(server, _serverKey)) {
            lock name="server.#_serverKey#" timeout="#variables.lockTimeout#" {
                if (!structKeyExists(server, _serverKey))
                    server[_serverKey] = createObject('component', 'javaloader.JavaLoader').init(
                        argumentCollection = javaLoaderInitArgs
                    );
            }
        }

        return server[_serverKey];
    }


    /********** PRIVATE *******************************************************/


    private struct function buildJavaLoaderInitArgs(
        array loadPaths,
        boolean loadColdFusionClassPath,
        string parentClassLoader,
        array sourceDirectories,
        string compileDirectory,
        boolean trustedSource,
        array loadRelativePaths
    ) {
        var initArgs = {};

        for (
            var argName in [
                'loadPaths',
                'loadColdFusionClassPath',
                'parentClassLoader',
                'sourceDirectories',
                'compileDirectory',
                'trustedSource'
            ]
        ) {
            if (structKeyExists(arguments, argName)) initArgs[argName] = arguments[argName];
        }

        if (structKeyExists(arguments, 'loadRelativePaths') && arrayLen(arguments.loadRelativePaths)) {
            if (!structKeyExists(initArgs, 'loadPaths')) initArgs.loadPaths = [];

            for (var relPath in arguments.loadRelativePaths) {
                arrayAppend(initArgs.loadPaths, expandPath(relPath));
            }
        }

        return initArgs;
    }


    private string function calculateServerKey(struct javaLoaderInitArgs) {
        // variables.serverKey takes precedence, if exists
        if (structKeyExists(variables, 'serverKey')) return variables.serverKey;

        // hash init args, to generate unique key based on precise JavaLoader instance
        return hash(serializeJSON({javaLoader: arguments.javaLoaderInitArgs}));
    }

}